ರೋಡ್‌ರನ್ನರ್: PHP ಅನ್ನು ಸಾಯಲು ನಿರ್ಮಿಸಲಾಗಿಲ್ಲ, ಅಥವಾ ಗೋಲಾಂಗ್ ರಕ್ಷಿಸಲು

ಹೇ ಹಬ್ರ್! ನಾವು Badoo ನಲ್ಲಿ ಸಕ್ರಿಯರಾಗಿದ್ದೇವೆ PHP ಕಾರ್ಯಕ್ಷಮತೆಯ ಮೇಲೆ ಕೆಲಸ ಮಾಡುತ್ತಿದೆ, ನಾವು ಈ ಭಾಷೆಯಲ್ಲಿ ಸಾಕಷ್ಟು ದೊಡ್ಡ ವ್ಯವಸ್ಥೆಯನ್ನು ಹೊಂದಿರುವುದರಿಂದ ಮತ್ತು ಕಾರ್ಯಕ್ಷಮತೆಯ ಸಮಸ್ಯೆಯು ಹಣವನ್ನು ಉಳಿಸುವ ಸಮಸ್ಯೆಯಾಗಿದೆ. ಹತ್ತು ವರ್ಷಗಳ ಹಿಂದೆ, ನಾವು ಇದಕ್ಕಾಗಿ PHP-FPM ಅನ್ನು ರಚಿಸಿದ್ದೇವೆ, ಇದು ಮೊದಲಿಗೆ PHP ಗಾಗಿ ಪ್ಯಾಚ್‌ಗಳ ಗುಂಪಾಗಿತ್ತು ಮತ್ತು ನಂತರ ಅಧಿಕೃತ ವಿತರಣೆಯನ್ನು ಪ್ರವೇಶಿಸಿತು.

ಇತ್ತೀಚಿನ ವರ್ಷಗಳಲ್ಲಿ, PHP ಉತ್ತಮ ಪ್ರಗತಿಯನ್ನು ಸಾಧಿಸಿದೆ: ಕಸ ಸಂಗ್ರಾಹಕವು ಸುಧಾರಿಸಿದೆ, ಸ್ಥಿರತೆಯ ಮಟ್ಟ ಹೆಚ್ಚಾಗಿದೆ - ಇಂದು ನೀವು ಯಾವುದೇ ಸಮಸ್ಯೆಗಳಿಲ್ಲದೆ PHP ನಲ್ಲಿ ಡೀಮನ್‌ಗಳು ಮತ್ತು ದೀರ್ಘಾವಧಿಯ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ಬರೆಯಬಹುದು. ಇದು ಸ್ಪೈರಲ್ ಸ್ಕೌಟ್‌ಗೆ ಮತ್ತಷ್ಟು ಹೋಗಲು ಅವಕಾಶ ಮಾಡಿಕೊಟ್ಟಿತು: ರೋಡ್‌ರನ್ನರ್, PHP-FPM ಗಿಂತ ಭಿನ್ನವಾಗಿ, ವಿನಂತಿಗಳ ನಡುವೆ ಮೆಮೊರಿಯನ್ನು ಸ್ವಚ್ಛಗೊಳಿಸುವುದಿಲ್ಲ, ಇದು ಹೆಚ್ಚುವರಿ ಕಾರ್ಯಕ್ಷಮತೆಯ ಲಾಭವನ್ನು ನೀಡುತ್ತದೆ (ಈ ವಿಧಾನವು ಅಭಿವೃದ್ಧಿ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸಂಕೀರ್ಣಗೊಳಿಸುತ್ತದೆ). ನಾವು ಪ್ರಸ್ತುತ ಈ ಉಪಕರಣವನ್ನು ಪ್ರಯೋಗಿಸುತ್ತಿದ್ದೇವೆ, ಆದರೆ ಹಂಚಿಕೊಳ್ಳಲು ನಾವು ಇನ್ನೂ ಯಾವುದೇ ಫಲಿತಾಂಶಗಳನ್ನು ಹೊಂದಿಲ್ಲ. ಅವರಿಗಾಗಿ ಕಾಯುವಿಕೆಯನ್ನು ಹೆಚ್ಚು ಮೋಜು ಮಾಡಲು, ಸ್ಪೈರಲ್ ಸ್ಕೌಟ್‌ನಿಂದ ರೋಡ್‌ರನ್ನರ್ ಪ್ರಕಟಣೆಯ ಅನುವಾದವನ್ನು ನಾವು ಪ್ರಕಟಿಸುತ್ತೇವೆ.

ಲೇಖನದ ವಿಧಾನವು ನಮಗೆ ಹತ್ತಿರದಲ್ಲಿದೆ: ನಮ್ಮ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸುವಾಗ, ನಾವು ಹೆಚ್ಚಾಗಿ PHP ಮತ್ತು Go ಅನ್ನು ಬಳಸುತ್ತೇವೆ, ಎರಡೂ ಭಾಷೆಗಳ ಪ್ರಯೋಜನಗಳನ್ನು ಪಡೆಯುತ್ತೇವೆ ಮತ್ತು ಒಂದನ್ನು ಇನ್ನೊಂದರ ಪರವಾಗಿ ತ್ಯಜಿಸುವುದಿಲ್ಲ.

ಆನಂದಿಸಿ!

ಕಳೆದ ಹತ್ತು ವರ್ಷಗಳಲ್ಲಿ, ನಾವು ಪಟ್ಟಿಯಿಂದ ಕಂಪನಿಗಳಿಗೆ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ರಚಿಸಿದ್ದೇವೆ ಫಾರ್ಚ್ಯೂನ್ 500, ಮತ್ತು 500 ಬಳಕೆದಾರರಿಗಿಂತ ಹೆಚ್ಚಿನ ಪ್ರೇಕ್ಷಕರನ್ನು ಹೊಂದಿರುವ ವ್ಯಾಪಾರಗಳಿಗೆ. ಈ ಸಮಯದಲ್ಲಿ, ನಮ್ಮ ಎಂಜಿನಿಯರ್‌ಗಳು ಮುಖ್ಯವಾಗಿ PHP ಯಲ್ಲಿ ಬ್ಯಾಕೆಂಡ್ ಅನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸುತ್ತಿದ್ದಾರೆ. ಆದರೆ ಎರಡು ವರ್ಷಗಳ ಹಿಂದೆ, ನಮ್ಮ ಉತ್ಪನ್ನಗಳ ಕಾರ್ಯಕ್ಷಮತೆಯ ಮೇಲೆ ಮಾತ್ರವಲ್ಲದೆ ಅವುಗಳ ಸ್ಕೇಲೆಬಿಲಿಟಿಯ ಮೇಲೂ ಏನಾದರೂ ದೊಡ್ಡ ಪರಿಣಾಮ ಬೀರಿದೆ - ನಾವು ನಮ್ಮ ತಂತ್ರಜ್ಞಾನದ ಸ್ಟಾಕ್‌ಗೆ ಗೋಲಾಂಗ್ (ಗೋ) ಅನ್ನು ಪರಿಚಯಿಸಿದ್ದೇವೆ.

ಬಹುತೇಕ ತಕ್ಷಣವೇ, 40x ವರೆಗಿನ ಕಾರ್ಯಕ್ಷಮತೆಯ ಸುಧಾರಣೆಗಳೊಂದಿಗೆ ದೊಡ್ಡ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು Go ನಮಗೆ ಅವಕಾಶ ಮಾಡಿಕೊಟ್ಟಿದೆ ಎಂದು ನಾವು ಕಂಡುಹಿಡಿದಿದ್ದೇವೆ. ಅದರೊಂದಿಗೆ, ನಾವು ನಮ್ಮ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ PHP ಉತ್ಪನ್ನಗಳನ್ನು ವಿಸ್ತರಿಸಲು ಸಾಧ್ಯವಾಯಿತು, ಎರಡೂ ಭಾಷೆಗಳ ಪ್ರಯೋಜನಗಳನ್ನು ಸಂಯೋಜಿಸುವ ಮೂಲಕ ಅವುಗಳನ್ನು ಸುಧಾರಿಸುತ್ತದೆ.

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

ನಿಮ್ಮ ದೈನಂದಿನ PHP ಅಭಿವೃದ್ಧಿ ಪರಿಸರ

PHP ಡೈಯಿಂಗ್ ಮಾಡೆಲ್ ಅನ್ನು ಪುನರುಜ್ಜೀವನಗೊಳಿಸಲು ನೀವು Go ಅನ್ನು ಹೇಗೆ ಬಳಸಬಹುದು ಎಂಬುದರ ಕುರಿತು ನಾವು ಮಾತನಾಡುವ ಮೊದಲು, ನಿಮ್ಮ ಡೀಫಾಲ್ಟ್ PHP ಅಭಿವೃದ್ಧಿ ಪರಿಸರವನ್ನು ನೋಡೋಣ.

ಹೆಚ್ಚಿನ ಸಂದರ್ಭಗಳಲ್ಲಿ, ನೀವು nginx ವೆಬ್ ಸರ್ವರ್ ಮತ್ತು PHP-FPM ಸರ್ವರ್ ಸಂಯೋಜನೆಯನ್ನು ಬಳಸಿಕೊಂಡು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ರನ್ ಮಾಡುತ್ತೀರಿ. ಹಿಂದಿನದು ಸ್ಥಿರ ಫೈಲ್‌ಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ ಮತ್ತು ನಿರ್ದಿಷ್ಟ ವಿನಂತಿಗಳನ್ನು PHP-FPM ಗೆ ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ, ಆದರೆ PHP-FPM ಸ್ವತಃ PHP ಕೋಡ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ. ನೀವು ಕಡಿಮೆ ಜನಪ್ರಿಯವಾದ Apache ಮತ್ತು mod_php ಸಂಯೋಜನೆಯನ್ನು ಬಳಸುತ್ತಿರಬಹುದು. ಆದರೆ ಇದು ಸ್ವಲ್ಪ ವಿಭಿನ್ನವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆಯಾದರೂ, ತತ್ವಗಳು ಒಂದೇ ಆಗಿರುತ್ತವೆ.

PHP-FPM ಅಪ್ಲಿಕೇಶನ್ ಕೋಡ್ ಅನ್ನು ಹೇಗೆ ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ನೋಡೋಣ. ವಿನಂತಿಯು ಬಂದಾಗ, PHP-FPM PHP ಚೈಲ್ಡ್ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತದೆ ಮತ್ತು ವಿನಂತಿಯ ವಿವರಗಳನ್ನು ಅದರ ರಾಜ್ಯದ ಭಾಗವಾಗಿ ರವಾನಿಸುತ್ತದೆ (_GET, _POST, _SERVER, ಇತ್ಯಾದಿ.).

PHP ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯ ಸಮಯದಲ್ಲಿ ರಾಜ್ಯವು ಬದಲಾಗುವುದಿಲ್ಲ, ಆದ್ದರಿಂದ ಹೊಸ ಇನ್‌ಪುಟ್ ಡೇಟಾವನ್ನು ಪಡೆಯುವ ಏಕೈಕ ಮಾರ್ಗವೆಂದರೆ ಪ್ರಕ್ರಿಯೆಯ ಮೆಮೊರಿಯನ್ನು ತೆರವುಗೊಳಿಸುವುದು ಮತ್ತು ಅದನ್ನು ಮತ್ತೆ ಪ್ರಾರಂಭಿಸುವುದು.

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

ನಿಯಮಿತ PHP ಪರಿಸರದ ಅನಾನುಕೂಲಗಳು ಮತ್ತು ಅಸಮರ್ಥತೆಗಳು

ನೀವು ವೃತ್ತಿಪರ PHP ಡೆವಲಪರ್ ಆಗಿದ್ದರೆ, ಚೌಕಟ್ಟಿನ ಆಯ್ಕೆಯೊಂದಿಗೆ ಹೊಸ ಯೋಜನೆಯನ್ನು ಎಲ್ಲಿ ಪ್ರಾರಂಭಿಸಬೇಕು ಎಂದು ನಿಮಗೆ ತಿಳಿದಿದೆ. ಇದು ಅವಲಂಬನೆ ಇಂಜೆಕ್ಷನ್ ಲೈಬ್ರರಿಗಳು, ORM ಗಳು, ಅನುವಾದಗಳು ಮತ್ತು ಟೆಂಪ್ಲೇಟ್‌ಗಳನ್ನು ಒಳಗೊಂಡಿದೆ. ಮತ್ತು, ಸಹಜವಾಗಿ, ಎಲ್ಲಾ ಬಳಕೆದಾರ ಇನ್‌ಪುಟ್ ಅನ್ನು ಅನುಕೂಲಕರವಾಗಿ ಒಂದು ವಸ್ತುವಿಗೆ ಹಾಕಬಹುದು (Symfony/HttpFoundation ಅಥವಾ PSR-7). ಚೌಕಟ್ಟುಗಳು ತಂಪಾಗಿವೆ!

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

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

Go ನೊಂದಿಗೆ PHP ಒಂದಕ್ಕಿಂತ ಹೆಚ್ಚು ವಿನಂತಿಗಳನ್ನು ಉಳಿಸಬಹುದೇ?

ಕೆಲವು ನಿಮಿಷಗಳಿಗಿಂತ ಹೆಚ್ಚು ಕಾಲ (ಗಂಟೆಗಳು ಅಥವಾ ದಿನಗಳವರೆಗೆ) ಬದುಕುವ PHP ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ಬರೆಯಲು ಸಾಧ್ಯವಿದೆ: ಉದಾಹರಣೆಗೆ, ಕ್ರಾನ್ ಕಾರ್ಯಗಳು, CSV ಪಾರ್ಸರ್‌ಗಳು, ಕ್ಯೂ ಬ್ರೇಕರ್‌ಗಳು. ಅವರೆಲ್ಲರೂ ಒಂದೇ ಸನ್ನಿವೇಶದ ಪ್ರಕಾರ ಕೆಲಸ ಮಾಡುತ್ತಾರೆ: ಅವರು ಕಾರ್ಯವನ್ನು ಹಿಂಪಡೆಯುತ್ತಾರೆ, ಅದನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತಾರೆ ಮತ್ತು ಮುಂದಿನದಕ್ಕಾಗಿ ಕಾಯುತ್ತಾರೆ. ಕೋಡ್ ಎಲ್ಲಾ ಸಮಯದಲ್ಲೂ ಮೆಮೊರಿಯಲ್ಲಿ ಇರುತ್ತದೆ, ಫ್ರೇಮ್‌ವರ್ಕ್ ಮತ್ತು ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಲೋಡ್ ಮಾಡಲು ಅಗತ್ಯವಿರುವ ಹಲವು ಹೆಚ್ಚುವರಿ ಹಂತಗಳಿರುವುದರಿಂದ ಅಮೂಲ್ಯವಾದ ಮಿಲಿಸೆಕೆಂಡುಗಳನ್ನು ಉಳಿಸುತ್ತದೆ.

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

PHP 7 ಬಿಡುಗಡೆಯೊಂದಿಗೆ ಪರಿಸ್ಥಿತಿ ಸುಧಾರಿಸಿದೆ: ವಿಶ್ವಾಸಾರ್ಹ ಕಸ ಸಂಗ್ರಾಹಕ ಕಾಣಿಸಿಕೊಂಡಿದೆ, ದೋಷಗಳನ್ನು ನಿಭಾಯಿಸಲು ಇದು ಸುಲಭವಾಗಿದೆ ಮತ್ತು ಕರ್ನಲ್ ವಿಸ್ತರಣೆಗಳು ಈಗ ಸೋರಿಕೆ-ನಿರೋಧಕವಾಗಿದೆ. ನಿಜ, ಎಂಜಿನಿಯರ್‌ಗಳು ಇನ್ನೂ ಮೆಮೊರಿಯೊಂದಿಗೆ ಜಾಗರೂಕರಾಗಿರಬೇಕು ಮತ್ತು ಕೋಡ್‌ನಲ್ಲಿ ರಾಜ್ಯದ ಸಮಸ್ಯೆಗಳ ಬಗ್ಗೆ ತಿಳಿದಿರಬೇಕು (ಈ ವಿಷಯಗಳನ್ನು ನಿರ್ಲಕ್ಷಿಸುವ ಭಾಷೆ ಇದೆಯೇ?). ಇನ್ನೂ, PHP 7 ನಮಗೆ ಅಂಗಡಿಯಲ್ಲಿ ಕಡಿಮೆ ಆಶ್ಚರ್ಯವನ್ನು ಹೊಂದಿದೆ.

ದೀರ್ಘಾವಧಿಯ ಪಿಎಚ್‌ಪಿ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವ ಮಾದರಿಯನ್ನು ತೆಗೆದುಕೊಳ್ಳಲು, HTTP ವಿನಂತಿಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವಂತಹ ಹೆಚ್ಚು ಕ್ಷುಲ್ಲಕ ಕಾರ್ಯಗಳಿಗೆ ಹೊಂದಿಕೊಳ್ಳಲು ಮತ್ತು ಆ ಮೂಲಕ ಪ್ರತಿ ವಿನಂತಿಯೊಂದಿಗೆ ಮೊದಲಿನಿಂದ ಎಲ್ಲವನ್ನೂ ಲೋಡ್ ಮಾಡುವ ಅಗತ್ಯವನ್ನು ತೊಡೆದುಹಾಕಲು ಸಾಧ್ಯವೇ?

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

ನಾವು ವೆಬ್ ಸರ್ವರ್ ಅನ್ನು ಶುದ್ಧ PHP (PHP-PM) ನಲ್ಲಿ ಬರೆಯಬಹುದು ಅಥವಾ C ವಿಸ್ತರಣೆಯನ್ನು (Swoole) ಬಳಸಬಹುದೆಂದು ನಮಗೆ ತಿಳಿದಿತ್ತು. ಮತ್ತು ಪ್ರತಿಯೊಂದು ವಿಧಾನವು ತನ್ನದೇ ಆದ ಅರ್ಹತೆಗಳನ್ನು ಹೊಂದಿದ್ದರೂ, ಎರಡೂ ಆಯ್ಕೆಗಳು ನಮಗೆ ಸರಿಹೊಂದುವುದಿಲ್ಲ - ನಾವು ಹೆಚ್ಚಿನದನ್ನು ಬಯಸುತ್ತೇವೆ. ನಮಗೆ ಕೇವಲ ವೆಬ್ ಸರ್ವರ್‌ಗಿಂತ ಹೆಚ್ಚಿನ ಅಗತ್ಯವಿತ್ತು - PHP ಯಲ್ಲಿನ "ಹಾರ್ಡ್ ಸ್ಟಾರ್ಟ್" ಗೆ ಸಂಬಂಧಿಸಿದ ಸಮಸ್ಯೆಗಳಿಂದ ನಮ್ಮನ್ನು ಉಳಿಸಬಹುದಾದ ಪರಿಹಾರವನ್ನು ನಾವು ನಿರೀಕ್ಷಿಸಿದ್ದೇವೆ, ಅದೇ ಸಮಯದಲ್ಲಿ ಅದನ್ನು ಸುಲಭವಾಗಿ ಅಳವಡಿಸಿಕೊಳ್ಳಬಹುದು ಮತ್ತು ನಿರ್ದಿಷ್ಟ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ವಿಸ್ತರಿಸಬಹುದು. ಅಂದರೆ, ನಮಗೆ ಅಪ್ಲಿಕೇಶನ್ ಸರ್ವರ್ ಅಗತ್ಯವಿದೆ.

ಇದಕ್ಕೆ ಸಹಾಯ ಮಾಡಲು ಹೋಗಬಹುದೇ? ಭಾಷೆ ಒಂದೇ ಬೈನರಿಗಳಾಗಿ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಕಂಪೈಲ್ ಮಾಡುವುದರಿಂದ ಅದು ಸಾಧ್ಯ ಎಂದು ನಮಗೆ ತಿಳಿದಿತ್ತು; ಇದು ಅಡ್ಡ-ವೇದಿಕೆಯಾಗಿದೆ; HTTP ಯೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ತನ್ನದೇ ಆದ, ಅತ್ಯಂತ ಸೊಗಸಾದ, ಸಮಾನಾಂತರ ಸಂಸ್ಕರಣಾ ಮಾದರಿ (ಕಾಕರೆನ್ಸಿ) ಮತ್ತು ಲೈಬ್ರರಿಯನ್ನು ಬಳಸುತ್ತದೆ; ಮತ್ತು ಅಂತಿಮವಾಗಿ, ಸಾವಿರಾರು ತೆರೆದ ಮೂಲ ಗ್ರಂಥಾಲಯಗಳು ಮತ್ತು ಏಕೀಕರಣಗಳು ನಮಗೆ ಲಭ್ಯವಿರುತ್ತವೆ.

ಎರಡು ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳನ್ನು ಸಂಯೋಜಿಸುವ ತೊಂದರೆಗಳು

ಮೊದಲನೆಯದಾಗಿ, ಎರಡು ಅಥವಾ ಹೆಚ್ಚಿನ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ಪರಸ್ಪರ ಹೇಗೆ ಸಂವಹನ ನಡೆಸುತ್ತವೆ ಎಂಬುದನ್ನು ನಿರ್ಧರಿಸುವುದು ಅಗತ್ಯವಾಗಿತ್ತು.

ಉದಾಹರಣೆಗೆ, ಬಳಸುವುದು ಅತ್ಯುತ್ತಮ ಗ್ರಂಥಾಲಯ ಅಲೆಕ್ಸ್ ಪ್ಯಾಲೆಸ್ಟ್ರಾಸ್, PHP ಮತ್ತು Go ಪ್ರಕ್ರಿಯೆಗಳ ನಡುವೆ ಮೆಮೊರಿಯನ್ನು ಹಂಚಿಕೊಳ್ಳಲು ಸಾಧ್ಯವಾಯಿತು (ಅಪಾಚೆಯಲ್ಲಿನ mod_php ಯಂತೆಯೇ). ಆದರೆ ಈ ಗ್ರಂಥಾಲಯವು ನಮ್ಮ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು ಅದರ ಬಳಕೆಯನ್ನು ಮಿತಿಗೊಳಿಸುವ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಹೊಂದಿದೆ.

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

ಪ್ರಾರಂಭಿಸಲು, ಪ್ರಕ್ರಿಯೆಗಳ ನಡುವೆ ಡೇಟಾವನ್ನು ವಿನಿಮಯ ಮಾಡಿಕೊಳ್ಳಲು ಮತ್ತು ಪ್ರಸರಣ ದೋಷಗಳನ್ನು ನಿರ್ವಹಿಸಲು ನಾವು ಸರಳ ಬೈನರಿ ಪ್ರೋಟೋಕಾಲ್ ಅನ್ನು ರಚಿಸಿದ್ದೇವೆ. ಅದರ ಸರಳ ರೂಪದಲ್ಲಿ, ಈ ರೀತಿಯ ಪ್ರೋಟೋಕಾಲ್ ಹೋಲುತ್ತದೆ ನೆಟ್ಸ್ಟ್ರಿಂಗ್ с ಸ್ಥಿರ ಗಾತ್ರದ ಪ್ಯಾಕೆಟ್ ಹೆಡರ್ (ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ 17 ಬೈಟ್‌ಗಳು), ಇದು ಪ್ಯಾಕೆಟ್‌ನ ಪ್ರಕಾರ, ಅದರ ಗಾತ್ರ ಮತ್ತು ಡೇಟಾದ ಸಮಗ್ರತೆಯನ್ನು ಪರಿಶೀಲಿಸಲು ಬೈನರಿ ಮಾಸ್ಕ್ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಒಳಗೊಂಡಿದೆ.

ನಾವು ಬಳಸಿದ PHP ಭಾಗದಲ್ಲಿ ಪ್ಯಾಕ್ ಕಾರ್ಯ, ಮತ್ತು ಗೋ ಬದಿಯಲ್ಲಿ, ಲೈಬ್ರರಿ ಎನ್ಕೋಡಿಂಗ್/ಬೈನರಿ.

ಒಂದು ಪ್ರೋಟೋಕಾಲ್ ಸಾಕಾಗುವುದಿಲ್ಲ ಎಂದು ನಮಗೆ ತೋರುತ್ತದೆ - ಮತ್ತು ನಾವು ಕರೆ ಮಾಡುವ ಸಾಮರ್ಥ್ಯವನ್ನು ಸೇರಿಸಿದ್ದೇವೆ net/rpc go ಸೇವೆಗಳು ನೇರವಾಗಿ PHP ನಿಂದ. ನಂತರ, ಇದು ನಮಗೆ ಅಭಿವೃದ್ಧಿಯಲ್ಲಿ ಬಹಳಷ್ಟು ಸಹಾಯ ಮಾಡಿತು, ಏಕೆಂದರೆ ನಾವು ಗೋ ಲೈಬ್ರರಿಗಳನ್ನು PHP ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ ಸುಲಭವಾಗಿ ಸಂಯೋಜಿಸಬಹುದು. ಈ ಕೆಲಸದ ಫಲಿತಾಂಶವನ್ನು ನೋಡಬಹುದು, ಉದಾಹರಣೆಗೆ, ನಮ್ಮ ಇತರ ತೆರೆದ ಮೂಲ ಉತ್ಪನ್ನದಲ್ಲಿ ಗೋರಿಡ್ಜ್.

ಬಹು PHP ಕೆಲಸಗಾರರಿಗೆ ಕಾರ್ಯಗಳನ್ನು ವಿತರಿಸುವುದು

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

ಸಕ್ರಿಯ ಕಾರ್ಮಿಕರ ಪೂಲ್ ಅನ್ನು ಸಂಗ್ರಹಿಸಲು, ನಾವು ಬಳಸಿದ್ದೇವೆ ಬಫರ್ ಚಾನಲ್, ಪೂಲ್‌ನಿಂದ ಅನಿರೀಕ್ಷಿತವಾಗಿ "ಸತ್ತ" ಕಾರ್ಮಿಕರನ್ನು ತೆಗೆದುಹಾಕಲು, ನಾವು ಟ್ರ್ಯಾಕಿಂಗ್ ದೋಷಗಳು ಮತ್ತು ಕಾರ್ಮಿಕರ ಸ್ಥಿತಿಗಳಿಗೆ ಯಾಂತ್ರಿಕ ವ್ಯವಸ್ಥೆಯನ್ನು ಸೇರಿಸಿದ್ದೇವೆ.

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

ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ವೆಬ್ ಸರ್ವರ್ ಆಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸಲು ಪ್ರಾರಂಭಿಸಲು, ಯಾವುದೇ ಒಳಬರುವ HTTP ವಿನಂತಿಗಳನ್ನು ಪ್ರತಿನಿಧಿಸಲು ನಾವು ವಿಶ್ವಾಸಾರ್ಹ PHP ಮಾನದಂಡವನ್ನು ಆರಿಸಬೇಕಾಗುತ್ತದೆ. ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಕೇವಲ ರೂಪಾಂತರ ಫಾರ್ಮ್ಯಾಟ್‌ಗೆ ಹೋಗಿ ನಿಂದ net/http ವಿನಂತಿ PSR-7ಆದ್ದರಿಂದ ಇದು ಇಂದು ಲಭ್ಯವಿರುವ ಹೆಚ್ಚಿನ PHP ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗಳೊಂದಿಗೆ ಹೊಂದಿಕೊಳ್ಳುತ್ತದೆ.

PSR-7 ಅನ್ನು ಅಸ್ಥಿರವೆಂದು ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ (ಕೆಲವರು ತಾಂತ್ರಿಕವಾಗಿ ಅದು ಅಲ್ಲ ಎಂದು ಹೇಳುತ್ತಾರೆ), ಡೆವಲಪರ್‌ಗಳು ವಿನಂತಿಯನ್ನು ತಾತ್ವಿಕವಾಗಿ ಜಾಗತಿಕ ಘಟಕವಾಗಿ ಪರಿಗಣಿಸದ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಬರೆಯಬೇಕಾಗುತ್ತದೆ. ಇದು ದೀರ್ಘಾವಧಿಯ PHP ಪ್ರಕ್ರಿಯೆಗಳ ಪರಿಕಲ್ಪನೆಯೊಂದಿಗೆ ಚೆನ್ನಾಗಿ ಹೊಂದಿಕೊಳ್ಳುತ್ತದೆ. ಇನ್ನೂ ಹೆಸರಿಸದ ನಮ್ಮ ಅಂತಿಮ ಅನುಷ್ಠಾನವು ಈ ರೀತಿ ಕಾಣುತ್ತದೆ:

ರೋಡ್ ರನ್ನರ್ ಅನ್ನು ಪರಿಚಯಿಸಲಾಗುತ್ತಿದೆ - ಹೆಚ್ಚಿನ ಕಾರ್ಯಕ್ಷಮತೆಯ PHP ಅಪ್ಲಿಕೇಶನ್ ಸರ್ವರ್

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

ಈ ಪರಿಹಾರವನ್ನು ಬದಲಿಸಲು, ನಾವು 2018 ರ ಆರಂಭದಲ್ಲಿ ನಮ್ಮ ಮೊದಲ PHP/Go ಅಪ್ಲಿಕೇಶನ್ ಸರ್ವರ್ ಅನ್ನು ನಿಯೋಜಿಸಿದ್ದೇವೆ. ಮತ್ತು ತಕ್ಷಣವೇ ನಂಬಲಾಗದ ಪರಿಣಾಮವನ್ನು ಪಡೆಯಿತು! ನಾವು 502 ದೋಷವನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ತೊಡೆದುಹಾಕಲು ಮಾತ್ರವಲ್ಲದೆ, ನಾವು ಸರ್ವರ್‌ಗಳ ಸಂಖ್ಯೆಯನ್ನು ಮೂರನೇ ಎರಡರಷ್ಟು ಕಡಿಮೆ ಮಾಡಲು ಸಾಧ್ಯವಾಯಿತು, ಇಂಜಿನಿಯರ್‌ಗಳು ಮತ್ತು ಉತ್ಪನ್ನ ನಿರ್ವಾಹಕರಿಗೆ ಬಹಳಷ್ಟು ಹಣವನ್ನು ಮತ್ತು ತಲೆನೋವು ಮಾತ್ರೆಗಳನ್ನು ಉಳಿಸಿದ್ದೇವೆ.

ವರ್ಷದ ಮಧ್ಯದಲ್ಲಿ, ನಾವು ನಮ್ಮ ಪರಿಹಾರವನ್ನು ಸುಧಾರಿಸಿದ್ದೇವೆ, ಅದನ್ನು MIT ಪರವಾನಗಿ ಅಡಿಯಲ್ಲಿ GitHub ನಲ್ಲಿ ಪ್ರಕಟಿಸಿದ್ದೇವೆ ಮತ್ತು ಅದನ್ನು ಹೆಸರಿಸಿದ್ದೇವೆ ರೋಡ್ರನ್ನರ್, ಹೀಗೆ ಅದರ ನಂಬಲಾಗದ ವೇಗ ಮತ್ತು ದಕ್ಷತೆಯನ್ನು ಒತ್ತಿಹೇಳುತ್ತದೆ.

ರೋಡ್ ರನ್ನರ್ ನಿಮ್ಮ ಅಭಿವೃದ್ಧಿ ಸ್ಟಾಕ್ ಅನ್ನು ಹೇಗೆ ಸುಧಾರಿಸಬಹುದು

ಅಪ್ಲಿಕೇಶನ್ ರೋಡ್ರನ್ನರ್ ವಿನಂತಿಯು PHP ಅನ್ನು ತಲುಪುವ ಮೊದಲು JWT ಪರಿಶೀಲನೆಯನ್ನು ನಿರ್ವಹಿಸಲು Go ಭಾಗದಲ್ಲಿ Middleware net/http ಅನ್ನು ಬಳಸಲು ನಮಗೆ ಅವಕಾಶ ಮಾಡಿಕೊಟ್ಟಿತು, ಜೊತೆಗೆ WebSockets ಅನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ ಮತ್ತು Prometheus ನಲ್ಲಿ ಜಾಗತಿಕವಾಗಿ ಸ್ಥಿತಿಯನ್ನು ಒಟ್ಟುಗೂಡಿಸುತ್ತದೆ.

ಅಂತರ್ನಿರ್ಮಿತ RPC ಗೆ ಧನ್ಯವಾದಗಳು, ನೀವು ವಿಸ್ತರಣೆಯ ಹೊದಿಕೆಗಳನ್ನು ಬರೆಯದೆಯೇ PHP ಗಾಗಿ ಯಾವುದೇ Go ಲೈಬ್ರರಿಗಳ API ಅನ್ನು ತೆರೆಯಬಹುದು. ಹೆಚ್ಚು ಮುಖ್ಯವಾಗಿ, ರೋಡ್‌ರನ್ನರ್‌ನೊಂದಿಗೆ ನೀವು ಹೊಸ HTTP ಅಲ್ಲದ ಸರ್ವರ್‌ಗಳನ್ನು ನಿಯೋಜಿಸಬಹುದು. ಉದಾಹರಣೆಗಳಲ್ಲಿ PHP ನಲ್ಲಿ ರನ್ನಿಂಗ್ ಹ್ಯಾಂಡ್ಲರ್‌ಗಳು ಸೇರಿವೆ ಎಡಬ್ಲ್ಯೂಎಸ್ ಲ್ಯಾಂಬ್ಡಾ, ವಿಶ್ವಾಸಾರ್ಹ ಕ್ಯೂ ಬ್ರೇಕರ್‌ಗಳನ್ನು ರಚಿಸುವುದು ಮತ್ತು ಸೇರಿಸುವುದು gRPC ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ.

PHP ಮತ್ತು Go ಸಮುದಾಯಗಳ ಸಹಾಯದಿಂದ, ನಾವು ಪರಿಹಾರದ ಸ್ಥಿರತೆಯನ್ನು ಸುಧಾರಿಸಿದ್ದೇವೆ, ಕೆಲವು ಪರೀಕ್ಷೆಗಳಲ್ಲಿ ಅಪ್ಲಿಕೇಶನ್ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು 40 ಪಟ್ಟು ಹೆಚ್ಚಿಸಿದ್ದೇವೆ, ಸುಧಾರಿತ ಡೀಬಗ್ ಮಾಡುವ ಪರಿಕರಗಳು, Symfony ಫ್ರೇಮ್‌ವರ್ಕ್‌ನೊಂದಿಗೆ ಅಳವಡಿಸಲಾದ ಏಕೀಕರಣ ಮತ್ತು HTTPS, HTTP/2 ಗೆ ಬೆಂಬಲವನ್ನು ಸೇರಿಸಿದ್ದೇವೆ, ಪ್ಲಗಿನ್‌ಗಳು ಮತ್ತು PSR-17.

ತೀರ್ಮಾನಕ್ಕೆ

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

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

Go ಮತ್ತು PHP ಯ ಗುಂಪಿನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಿದ ನಂತರ, ನಾವು ಅವರನ್ನು ಪ್ರೀತಿಸುತ್ತೇವೆ ಎಂದು ಹೇಳಬಹುದು. ನಾವು ಒಂದನ್ನು ಇನ್ನೊಂದಕ್ಕೆ ತ್ಯಾಗ ಮಾಡಲು ಯೋಜಿಸುವುದಿಲ್ಲ - ಇದಕ್ಕೆ ವಿರುದ್ಧವಾಗಿ, ಈ ಡ್ಯುಯಲ್ ಸ್ಟಾಕ್‌ನಿಂದ ಇನ್ನಷ್ಟು ಮೌಲ್ಯವನ್ನು ಪಡೆಯುವ ಮಾರ್ಗಗಳನ್ನು ನಾವು ಹುಡುಕುತ್ತೇವೆ.

UPD: ರೋಡ್‌ರನ್ನರ್‌ನ ಸೃಷ್ಟಿಕರ್ತ ಮತ್ತು ಮೂಲ ಲೇಖನದ ಸಹ-ಲೇಖಕರನ್ನು ನಾವು ಸ್ವಾಗತಿಸುತ್ತೇವೆ - ಲಾಚೆಸಿಸ್

ಮೂಲ: www.habr.com