ಹಬ್ರ್, ಹಲೋ! ನಿನ್ನೆ ರಂದು , Rambler&Co ನ ಹುಡುಗರಿಂದ, ಈ ಪರಿಕರವನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡುವುದಕ್ಕೆ ಸಂಬಂಧಿಸಿದಂತೆ ಭಾಗವಹಿಸುವವರಿಂದ ಸಾಕಷ್ಟು ಪ್ರಶ್ನೆಗಳಿವೆ. ನಾವು ಅವರ ಹೆಜ್ಜೆಗಳನ್ನು ಅನುಸರಿಸಲು ಮತ್ತು ನಮ್ಮ ಅನುಭವವನ್ನು ಹಂಚಿಕೊಳ್ಳಲು ನಿರ್ಧರಿಸಿದ್ದೇವೆ. ವಿಷಯವು ಸುಲಭವಲ್ಲ - ಆದ್ದರಿಂದ ನಿಮ್ಮ ಅನುಭವವನ್ನು ಕಾಮೆಂಟ್‌ಗಳಲ್ಲಿ ಹಂಚಿಕೊಳ್ಳಲು ನಾವು ನಿಮ್ಮನ್ನು ಆಹ್ವಾನಿಸುತ್ತೇವೆ, ಬಹುಶಃ ನಾವು ಏನಾದರೂ ತಪ್ಪಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳುತ್ತೇವೆ ಮತ್ತು ಬಳಸುತ್ತೇವೆ.
ನಾವು ಸ್ಪಾರ್ಕ್ ಅನ್ನು ಹೇಗೆ ಬಳಸುತ್ತೇವೆ ಎಂಬುದರ ಕುರಿತು ಸ್ವಲ್ಪ ಪರಿಚಯ. ನಮ್ಮಲ್ಲಿ ಮೂರು ತಿಂಗಳ ಕಾರ್ಯಕ್ರಮವಿದೆ , ಮತ್ತು ಎರಡನೇ ಮಾಡ್ಯೂಲ್‌ನಾದ್ಯಂತ ನಮ್ಮ ಭಾಗವಹಿಸುವವರು ಈ ಉಪಕರಣದಲ್ಲಿ ಕೆಲಸ ಮಾಡುತ್ತಾರೆ. ಅಂತೆಯೇ, ಸಂಘಟಕರಾಗಿ ನಮ್ಮ ಕಾರ್ಯವು ಅಂತಹ ಸಂದರ್ಭದಲ್ಲಿ ಬಳಕೆಗಾಗಿ ಕ್ಲಸ್ಟರ್ ಅನ್ನು ಸಿದ್ಧಪಡಿಸುವುದು.
ನಮ್ಮ ಬಳಕೆಯ ವಿಶಿಷ್ಟತೆಯೆಂದರೆ ಸ್ಪಾರ್ಕ್‌ನಲ್ಲಿ ಏಕಕಾಲದಲ್ಲಿ ಕೆಲಸ ಮಾಡುವ ಜನರ ಸಂಖ್ಯೆಯು ಇಡೀ ಗುಂಪಿಗೆ ಸಮನಾಗಿರುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಸೆಮಿನಾರ್‌ನಲ್ಲಿ, ಪ್ರತಿಯೊಬ್ಬರೂ ಒಂದೇ ಸಮಯದಲ್ಲಿ ಏನನ್ನಾದರೂ ಪ್ರಯತ್ನಿಸಿದಾಗ ಮತ್ತು ನಮ್ಮ ಶಿಕ್ಷಕರ ನಂತರ ಪುನರಾವರ್ತಿಸಿದಾಗ. ಮತ್ತು ಇದು ಬಹಳಷ್ಟು ಅಲ್ಲ - ಕೆಲವೊಮ್ಮೆ 40 ಜನರವರೆಗೆ. ಅಂತಹ ಬಳಕೆಯ ಪ್ರಕರಣವನ್ನು ಎದುರಿಸುವ ಅನೇಕ ಕಂಪನಿಗಳು ಬಹುಶಃ ಜಗತ್ತಿನಲ್ಲಿ ಇಲ್ಲ.
ಮುಂದೆ, ನಾವು ಕೆಲವು ಸಂರಚನಾ ನಿಯತಾಂಕಗಳನ್ನು ಹೇಗೆ ಮತ್ತು ಏಕೆ ಆಯ್ಕೆ ಮಾಡಿದ್ದೇವೆ ಎಂದು ನಾನು ನಿಮಗೆ ಹೇಳುತ್ತೇನೆ.
ಮೊದಲಿನಿಂದಲೂ ಪ್ರಾರಂಭಿಸೋಣ. ಸ್ಪಾರ್ಕ್ ಕ್ಲಸ್ಟರ್‌ನಲ್ಲಿ ರನ್ ಮಾಡಲು 3 ಆಯ್ಕೆಗಳನ್ನು ಹೊಂದಿದೆ: ಸ್ವತಂತ್ರ, ಮೆಸೊಸ್ ಅನ್ನು ಬಳಸುವುದು ಮತ್ತು ಯಾರ್ನ್ ಬಳಸುವುದು. ನಾವು ಮೂರನೇ ಆಯ್ಕೆಯನ್ನು ಆಯ್ಕೆ ಮಾಡಲು ನಿರ್ಧರಿಸಿದ್ದೇವೆ ಏಕೆಂದರೆ ಅದು ನಮಗೆ ಅರ್ಥವಾಗಿದೆ. ನಾವು ಈಗಾಗಲೇ ಹಡೂಪ್ ಕ್ಲಸ್ಟರ್ ಅನ್ನು ಹೊಂದಿದ್ದೇವೆ. ನಮ್ಮ ಭಾಗವಹಿಸುವವರು ಈಗಾಗಲೇ ಅದರ ವಾಸ್ತುಶಿಲ್ಪದೊಂದಿಗೆ ಚೆನ್ನಾಗಿ ಪರಿಚಿತರಾಗಿದ್ದಾರೆ. ನೂಲು ಬಳಸೋಣ.
spark.master=yarnಮತ್ತಷ್ಟು ಆಸಕ್ತಿದಾಯಕವಾಗಿದೆ. ಈ 3 ನಿಯೋಜನೆ ಆಯ್ಕೆಗಳಲ್ಲಿ ಪ್ರತಿಯೊಂದೂ 2 ನಿಯೋಜನೆ ಆಯ್ಕೆಗಳನ್ನು ಹೊಂದಿದೆ: ಕ್ಲೈಂಟ್ ಮತ್ತು ಕ್ಲಸ್ಟರ್. ಆಧಾರಿತ ಮತ್ತು ಅಂತರ್ಜಾಲದಲ್ಲಿನ ವಿವಿಧ ಲಿಂಕ್‌ಗಳು, ಕ್ಲೈಂಟ್ ಸಂವಾದಾತ್ಮಕ ಕೆಲಸಕ್ಕೆ ಸೂಕ್ತವಾಗಿದೆ ಎಂದು ನಾವು ತೀರ್ಮಾನಿಸಬಹುದು - ಉದಾಹರಣೆಗೆ, ಜೂಪಿಟರ್ ನೋಟ್‌ಬುಕ್ ಮೂಲಕ, ಮತ್ತು ಕ್ಲಸ್ಟರ್ ಉತ್ಪಾದನಾ ಪರಿಹಾರಗಳಿಗೆ ಹೆಚ್ಚು ಸೂಕ್ತವಾಗಿದೆ. ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಸಂವಾದಾತ್ಮಕ ಕೆಲಸದಲ್ಲಿ ಆಸಕ್ತಿ ಹೊಂದಿದ್ದೇವೆ, ಆದ್ದರಿಂದ:
spark.deploy-mode=clientಸಾಮಾನ್ಯವಾಗಿ, ಇಂದಿನಿಂದ ಸ್ಪಾರ್ಕ್ ಹೇಗಾದರೂ YARN ನಲ್ಲಿ ಕೆಲಸ ಮಾಡುತ್ತದೆ, ಆದರೆ ಇದು ನಮಗೆ ಸಾಕಾಗಲಿಲ್ಲ. ನಾವು ದೊಡ್ಡ ಡೇಟಾದ ಬಗ್ಗೆ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಹೊಂದಿರುವುದರಿಂದ, ಕೆಲವೊಮ್ಮೆ ಭಾಗವಹಿಸುವವರು ಸಂಪನ್ಮೂಲಗಳ ಸಮನಾದ ಸ್ಲೈಸಿಂಗ್ ಚೌಕಟ್ಟಿನೊಳಗೆ ಪಡೆದಿದ್ದನ್ನು ಸಾಕಷ್ಟು ಹೊಂದಿರುವುದಿಲ್ಲ. ತದನಂತರ ನಾವು ಆಸಕ್ತಿದಾಯಕ ವಿಷಯವನ್ನು ಕಂಡುಕೊಂಡಿದ್ದೇವೆ - ಡೈನಾಮಿಕ್ ಸಂಪನ್ಮೂಲ ಹಂಚಿಕೆ. ಸಂಕ್ಷಿಪ್ತವಾಗಿ, ಪಾಯಿಂಟ್ ಇದು: ನೀವು ಕಷ್ಟಕರವಾದ ಕೆಲಸವನ್ನು ಹೊಂದಿದ್ದರೆ ಮತ್ತು ಕ್ಲಸ್ಟರ್ ಉಚಿತವಾಗಿದ್ದರೆ (ಉದಾಹರಣೆಗೆ, ಬೆಳಿಗ್ಗೆ), ನಂತರ ಈ ಆಯ್ಕೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಸ್ಪಾರ್ಕ್ ನಿಮಗೆ ಹೆಚ್ಚುವರಿ ಸಂಪನ್ಮೂಲಗಳನ್ನು ನೀಡಬಹುದು. ಒಂದು ಕುತಂತ್ರ ಸೂತ್ರದ ಪ್ರಕಾರ ಅಲ್ಲಿ ಅವಶ್ಯಕತೆಯನ್ನು ಲೆಕ್ಕಹಾಕಲಾಗುತ್ತದೆ. ನಾವು ವಿವರಗಳಿಗೆ ಹೋಗುವುದಿಲ್ಲ - ಇದು ಉತ್ತಮವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.
spark.dynamicAllocation.enabled=trueನಾವು ಈ ಪ್ಯಾರಾಮೀಟರ್ ಅನ್ನು ಹೊಂದಿಸಿದ್ದೇವೆ ಮತ್ತು ಪ್ರಾರಂಭದಲ್ಲಿ ಸ್ಪಾರ್ಕ್ ಕ್ರ್ಯಾಶ್ ಆಗಿದೆ ಮತ್ತು ಪ್ರಾರಂಭಿಸಲಿಲ್ಲ. ಅದು ಸರಿ, ಏಕೆಂದರೆ ನಾನು ಅದನ್ನು ಓದಬೇಕಾಗಿತ್ತು ಹೆಚ್ಚು ಎಚ್ಚರಿಕೆಯಿಂದ. ಎಲ್ಲವೂ ಸರಿಯಾಗಿರಲು, ನೀವು ಹೆಚ್ಚುವರಿ ಪ್ಯಾರಾಮೀಟರ್ ಅನ್ನು ಸಹ ಸಕ್ರಿಯಗೊಳಿಸಬೇಕು ಎಂದು ಅದು ಹೇಳುತ್ತದೆ.
spark.shuffle.service.enabled=trueಅದು ಏಕೆ ಬೇಕು? ನಮ್ಮ ಕೆಲಸಕ್ಕೆ ಇನ್ನು ಮುಂದೆ ಹೆಚ್ಚಿನ ಸಂಪನ್ಮೂಲಗಳು ಅಗತ್ಯವಿಲ್ಲದಿದ್ದಾಗ, ಸ್ಪಾರ್ಕ್ ಅವುಗಳನ್ನು ಸಾಮಾನ್ಯ ಪೂಲ್ಗೆ ಹಿಂತಿರುಗಿಸಬೇಕು. ಯಾವುದೇ MapReduce ಕಾರ್ಯದಲ್ಲಿ ಹೆಚ್ಚು ಸಮಯ ತೆಗೆದುಕೊಳ್ಳುವ ಹಂತವೆಂದರೆ ಷಫಲ್ ಹಂತ. ಈ ಹಂತದಲ್ಲಿ ಉತ್ಪತ್ತಿಯಾಗುವ ಡೇಟಾವನ್ನು ಉಳಿಸಲು ಮತ್ತು ಅದಕ್ಕೆ ಅನುಗುಣವಾಗಿ ಕಾರ್ಯನಿರ್ವಾಹಕರನ್ನು ಬಿಡುಗಡೆ ಮಾಡಲು ಈ ಪ್ಯಾರಾಮೀಟರ್ ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಮತ್ತು ಕಾರ್ಯನಿರ್ವಾಹಕನು ಕೆಲಸಗಾರನ ಮೇಲೆ ಎಲ್ಲವನ್ನೂ ಲೆಕ್ಕಾಚಾರ ಮಾಡುವ ಪ್ರಕ್ರಿಯೆಯಾಗಿದೆ. ಇದು ನಿರ್ದಿಷ್ಟ ಸಂಖ್ಯೆಯ ಪ್ರೊಸೆಸರ್ ಕೋರ್ಗಳನ್ನು ಮತ್ತು ನಿರ್ದಿಷ್ಟ ಪ್ರಮಾಣದ ಮೆಮೊರಿಯನ್ನು ಹೊಂದಿದೆ.
ಈ ನಿಯತಾಂಕವನ್ನು ಸೇರಿಸಲಾಗಿದೆ. ಎಲ್ಲವೂ ಕೆಲಸ ಮಾಡುವಂತಿತ್ತು. ಭಾಗವಹಿಸುವವರಿಗೆ ಅವರಿಗೆ ಅಗತ್ಯವಿರುವಾಗ ಹೆಚ್ಚಿನ ಸಂಪನ್ಮೂಲಗಳನ್ನು ನೀಡಲಾಯಿತು ಎಂಬುದು ಗಮನಾರ್ಹವಾಗಿದೆ. ಆದರೆ ಮತ್ತೊಂದು ಸಮಸ್ಯೆ ಉದ್ಭವಿಸಿತು - ಕೆಲವು ಹಂತದಲ್ಲಿ ಇತರ ಭಾಗವಹಿಸುವವರು ಎಚ್ಚರಗೊಂಡರು ಮತ್ತು ಸ್ಪಾರ್ಕ್ ಅನ್ನು ಬಳಸಲು ಬಯಸಿದ್ದರು, ಆದರೆ ಅಲ್ಲಿ ಎಲ್ಲವೂ ಕಾರ್ಯನಿರತವಾಗಿತ್ತು ಮತ್ತು ಅವರು ಅತೃಪ್ತರಾಗಿದ್ದರು. ಅವುಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬಹುದು. ನಾವು ದಾಖಲೆಗಳನ್ನು ನೋಡಲು ಪ್ರಾರಂಭಿಸಿದ್ದೇವೆ. ಪ್ರಕ್ರಿಯೆಯ ಮೇಲೆ ಪ್ರಭಾವ ಬೀರಲು ಬಳಸಬಹುದಾದ ಹಲವಾರು ಇತರ ನಿಯತಾಂಕಗಳಿವೆ ಎಂದು ಅದು ಬದಲಾಯಿತು. ಉದಾಹರಣೆಗೆ, ಎಕ್ಸಿಕ್ಯೂಟರ್ ಸ್ಟ್ಯಾಂಡ್‌ಬೈ ಮೋಡ್‌ನಲ್ಲಿದ್ದರೆ, ಯಾವ ಸಮಯದ ನಂತರ ಅದರಿಂದ ಸಂಪನ್ಮೂಲಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಬಹುದು?
spark.dynamicAllocation.executorIdleTimeout=120sನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ, ನಿಮ್ಮ ಕಾರ್ಯನಿರ್ವಾಹಕರು ಎರಡು ನಿಮಿಷಗಳವರೆಗೆ ಏನನ್ನೂ ಮಾಡದಿದ್ದರೆ, ದಯವಿಟ್ಟು ಅವರನ್ನು ಸಾಮಾನ್ಯ ಪೂಲ್ಗೆ ಹಿಂತಿರುಗಿ. ಆದರೆ ಈ ನಿಯತಾಂಕವು ಯಾವಾಗಲೂ ಸಾಕಾಗುವುದಿಲ್ಲ. ವ್ಯಕ್ತಿಯು ದೀರ್ಘಕಾಲದವರೆಗೆ ಏನನ್ನೂ ಮಾಡುತ್ತಿಲ್ಲ ಮತ್ತು ಸಂಪನ್ಮೂಲಗಳನ್ನು ಮುಕ್ತಗೊಳಿಸಲಾಗುತ್ತಿಲ್ಲ ಎಂಬುದು ಸ್ಪಷ್ಟವಾಗಿದೆ. ವಿಶೇಷ ಪ್ಯಾರಾಮೀಟರ್ ಕೂಡ ಇದೆ ಎಂದು ಅದು ಬದಲಾಯಿತು - ಕ್ಯಾಶ್ ಮಾಡಲಾದ ಡೇಟಾವನ್ನು ಒಳಗೊಂಡಿರುವ ಕಾರ್ಯನಿರ್ವಾಹಕರನ್ನು ಆಯ್ಕೆ ಮಾಡಲು ಯಾವ ಸಮಯದ ನಂತರ. ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ಈ ನಿಯತಾಂಕವು ಅನಂತವಾಗಿದೆ! ನಾವು ಅದನ್ನು ಸರಿಪಡಿಸಿದ್ದೇವೆ.
spark.dynamicAllocation.cachedExecutorIdleTimeout=600sಅಂದರೆ, ನಿಮ್ಮ ಕಾರ್ಯನಿರ್ವಾಹಕರು 5 ನಿಮಿಷಗಳ ಕಾಲ ಏನನ್ನೂ ಮಾಡದಿದ್ದರೆ, ಅವುಗಳನ್ನು ಸಾಮಾನ್ಯ ಪೂಲ್ಗೆ ನೀಡಿ. ಈ ಕ್ರಮದಲ್ಲಿ, ಹೆಚ್ಚಿನ ಸಂಖ್ಯೆಯ ಬಳಕೆದಾರರಿಗೆ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಬಿಡುಗಡೆ ಮಾಡುವ ಮತ್ತು ವಿತರಿಸುವ ವೇಗವು ಯೋಗ್ಯವಾಗಿದೆ. ಅಸಮಾಧಾನದ ಪ್ರಮಾಣ ಕಡಿಮೆಯಾಗಿದೆ. ಆದರೆ ನಾವು ಮುಂದೆ ಹೋಗಲು ನಿರ್ಧರಿಸಿದ್ದೇವೆ ಮತ್ತು ಪ್ರತಿ ಅಪ್ಲಿಕೇಶನ್‌ಗೆ ಗರಿಷ್ಠ ಸಂಖ್ಯೆಯ ಎಕ್ಸಿಕ್ಯೂಟರ್‌ಗಳನ್ನು ಮಿತಿಗೊಳಿಸಲು ನಿರ್ಧರಿಸಿದ್ದೇವೆ - ಮೂಲಭೂತವಾಗಿ ಪ್ರತಿ ಪ್ರೋಗ್ರಾಂ ಭಾಗವಹಿಸುವವರಿಗೆ.
spark.dynamicAllocation.maxExecutors=19ಈಗ, ಸಹಜವಾಗಿ, ಇನ್ನೊಂದು ಬದಿಯಲ್ಲಿ ಅತೃಪ್ತ ಜನರಿದ್ದಾರೆ - "ಕ್ಲಸ್ಟರ್ ನಿಷ್ಕ್ರಿಯವಾಗಿದೆ, ಮತ್ತು ನನ್ನ ಬಳಿ ಕೇವಲ 19 ಎಕ್ಸಿಕ್ಯೂಟರ್‌ಗಳಿವೆ," ಆದರೆ ನೀವು ಏನು ಮಾಡಬಹುದು? ನಮಗೆ ಕೆಲವು ರೀತಿಯ ಸರಿಯಾದ ಸಮತೋಲನ ಬೇಕು. ನೀವು ಎಲ್ಲರನ್ನು ಸಂತೋಷಪಡಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ.
ಮತ್ತು ನಮ್ಮ ಪ್ರಕರಣದ ನಿಶ್ಚಿತಗಳಿಗೆ ಸಂಬಂಧಿಸಿದ ಇನ್ನೂ ಒಂದು ಸಣ್ಣ ಕಥೆ. ಹೇಗಾದರೂ, ಹಲವಾರು ಜನರು ಪ್ರಾಯೋಗಿಕ ಪಾಠಕ್ಕಾಗಿ ತಡವಾಗಿ ಬಂದರು, ಮತ್ತು ಕೆಲವು ಕಾರಣಗಳಿಂದ ಅವರಿಗೆ ಸ್ಪಾರ್ಕ್ ಪ್ರಾರಂಭವಾಗಲಿಲ್ಲ. ನಾವು ಉಚಿತ ಸಂಪನ್ಮೂಲಗಳ ಪ್ರಮಾಣವನ್ನು ನೋಡಿದ್ದೇವೆ - ಅದು ಇದೆ ಎಂದು ತೋರುತ್ತದೆ. ಸ್ಪಾರ್ಕ್ ಪ್ರಾರಂಭವಾಗಬೇಕು. ಅದೃಷ್ಟವಶಾತ್, ಆ ಹೊತ್ತಿಗೆ ದಸ್ತಾವೇಜನ್ನು ಈಗಾಗಲೇ ಎಲ್ಲೋ ಸಬ್‌ಕಾರ್ಟೆಕ್ಸ್‌ಗೆ ಸೇರಿಸಲಾಗಿದೆ, ಮತ್ತು ಪ್ರಾರಂಭಿಸಿದಾಗ, ಸ್ಪಾರ್ಕ್ ಪ್ರಾರಂಭಿಸಲು ಪೋರ್ಟ್ ಅನ್ನು ಹುಡುಕುತ್ತದೆ ಎಂದು ನಾವು ನೆನಪಿಸಿಕೊಂಡಿದ್ದೇವೆ. ಶ್ರೇಣಿಯಲ್ಲಿನ ಮೊದಲ ಬಂದರು ಕಾರ್ಯನಿರತವಾಗಿದ್ದರೆ, ಅದು ಕ್ರಮವಾಗಿ ಮುಂದಿನದಕ್ಕೆ ಚಲಿಸುತ್ತದೆ. ಅದು ಉಚಿತವಾಗಿದ್ದರೆ, ಅದು ಸೆರೆಹಿಡಿಯುತ್ತದೆ. ಮತ್ತು ಇದಕ್ಕಾಗಿ ಗರಿಷ್ಠ ಸಂಖ್ಯೆಯ ಪ್ರಯತ್ನಗಳನ್ನು ಸೂಚಿಸುವ ನಿಯತಾಂಕವಿದೆ. ಡೀಫಾಲ್ಟ್ 16. ತರಗತಿಯಲ್ಲಿ ನಮ್ಮ ಗುಂಪಿನಲ್ಲಿರುವ ಜನರ ಸಂಖ್ಯೆಗಿಂತ ಕಡಿಮೆ ಸಂಖ್ಯೆ. ಅದರಂತೆ, 16 ಪ್ರಯತ್ನಗಳ ನಂತರ, ಸ್ಪಾರ್ಕ್ ಕೈಬಿಟ್ಟರು ಮತ್ತು ನಾನು ಪ್ರಾರಂಭಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ ಎಂದು ಹೇಳಿದರು. ನಾವು ಈ ಸೆಟ್ಟಿಂಗ್ ಅನ್ನು ಸರಿಪಡಿಸಿದ್ದೇವೆ.
spark.port.maxRetries=50ನಮ್ಮ ಪ್ರಕರಣದ ನಿಶ್ಚಿತಗಳಿಗೆ ಹೆಚ್ಚು ಸಂಬಂಧಿಸದ ಕೆಲವು ಸೆಟ್ಟಿಂಗ್‌ಗಳ ಬಗ್ಗೆ ನಾನು ಮುಂದೆ ಹೇಳುತ್ತೇನೆ.
ಸ್ಪಾರ್ಕ್ ಅನ್ನು ವೇಗವಾಗಿ ಪ್ರಾರಂಭಿಸಲು, SPARK_HOME ಹೋಮ್ ಡೈರೆಕ್ಟರಿಯಲ್ಲಿರುವ ಜಾರ್ ಫೋಲ್ಡರ್ ಅನ್ನು ಆರ್ಕೈವ್ ಮಾಡಲು ಮತ್ತು ಅದನ್ನು HDFS ನಲ್ಲಿ ಇರಿಸಲು ಶಿಫಾರಸು ಮಾಡಲಾಗಿದೆ. ಆಗ ಕೆಲಸಗಾರರಿಂದ ಈ ಜರ್ನಿಕ್ ಗಳನ್ನು ಲೋಡ್ ಮಾಡಿ ಸಮಯ ವ್ಯರ್ಥ ಮಾಡುವುದಿಲ್ಲ.
spark.yarn.archive=hdfs:///tmp/spark-archive.zipವೇಗವಾದ ಕಾರ್ಯಾಚರಣೆಗಾಗಿ ಕ್ರೈಯೊವನ್ನು ಧಾರಾವಾಹಿಯಾಗಿ ಬಳಸಲು ಸಹ ಶಿಫಾರಸು ಮಾಡಲಾಗಿದೆ. ಇದು ಡೀಫಾಲ್ಟ್ ಒಂದಕ್ಕಿಂತ ಹೆಚ್ಚು ಆಪ್ಟಿಮೈಸ್ ಆಗಿದೆ.
spark.serializer=org.apache.spark.serializer.KryoSerializerಮತ್ತು ಸ್ಪಾರ್ಕ್‌ನೊಂದಿಗೆ ದೀರ್ಘಕಾಲದ ಸಮಸ್ಯೆಯೂ ಇದೆ, ಅದು ಮೆಮೊರಿಯಿಂದ ಆಗಾಗ್ಗೆ ಕ್ರ್ಯಾಶ್ ಆಗುತ್ತದೆ. ಕೆಲಸಗಾರರು ಎಲ್ಲವನ್ನೂ ಲೆಕ್ಕಹಾಕಿದಾಗ ಮತ್ತು ಫಲಿತಾಂಶವನ್ನು ಚಾಲಕನಿಗೆ ಕಳುಹಿಸಿದ ಕ್ಷಣದಲ್ಲಿ ಇದು ಸಂಭವಿಸುತ್ತದೆ. ನಾವು ಈ ನಿಯತಾಂಕವನ್ನು ನಮಗಾಗಿ ದೊಡ್ಡದಾಗಿಸಿದ್ದೇವೆ. ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ಇದು 1GB ಆಗಿದೆ, ನಾವು ಅದನ್ನು 3 ಮಾಡಿದ್ದೇವೆ.
spark.driver.maxResultSize=3072ಮತ್ತು ಕೊನೆಯದಾಗಿ, ಸಿಹಿತಿಂಡಿಯಾಗಿ. HortonWorks ವಿತರಣೆಯಲ್ಲಿ ಸ್ಪಾರ್ಕ್ ಅನ್ನು ಆವೃತ್ತಿ 2.1 ಗೆ ನವೀಕರಿಸುವುದು ಹೇಗೆ - HDP 2.5.3.0. HDP ಯ ಈ ಆವೃತ್ತಿಯು ಪೂರ್ವ-ಸ್ಥಾಪಿತ ಆವೃತ್ತಿ 2.0 ಅನ್ನು ಹೊಂದಿದೆ, ಆದರೆ ಸ್ಪಾರ್ಕ್ ಸಾಕಷ್ಟು ಸಕ್ರಿಯವಾಗಿ ಅಭಿವೃದ್ಧಿ ಹೊಂದುತ್ತಿದೆ ಎಂದು ನಾವು ಒಮ್ಮೆ ನಿರ್ಧರಿಸಿದ್ದೇವೆ ಮತ್ತು ಪ್ರತಿ ಹೊಸ ಆವೃತ್ತಿಯು ಕೆಲವು ದೋಷಗಳನ್ನು ಸರಿಪಡಿಸುತ್ತದೆ ಮತ್ತು ಪೈಥಾನ್ API ಸೇರಿದಂತೆ ಹೆಚ್ಚುವರಿ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ, ಆದ್ದರಿಂದ ನಾವು ನಿರ್ಧರಿಸಿದ್ದೇವೆ , ಏನು ಬೇಕು ಮಾಡಲಾಗುವುದು ಒಂದು ನವೀಕರಣವಾಗಿದೆ.
ಹಡೂಪ್ 2.7 ಗಾಗಿ ಅಧಿಕೃತ ವೆಬ್‌ಸೈಟ್‌ನಿಂದ ಆವೃತ್ತಿಯನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡಲಾಗಿದೆ. ಅದನ್ನು ಅನ್ಜಿಪ್ ಮಾಡಿ ಮತ್ತು ಅದನ್ನು HDP ಫೋಲ್ಡರ್ನಲ್ಲಿ ಇರಿಸಿ. ಅಗತ್ಯವಿರುವಂತೆ ನಾವು ಸಿಮ್ಲಿಂಕ್ಗಳನ್ನು ಸ್ಥಾಪಿಸಿದ್ದೇವೆ. ನಾವು ಅದನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ - ಅದು ಪ್ರಾರಂಭವಾಗುವುದಿಲ್ಲ. ಬಹಳ ಅಸ್ಪಷ್ಟ ದೋಷವನ್ನು ಬರೆಯುತ್ತಾರೆ.
java.lang.NoClassDefFoundError: com/sun/jersey/api/client/config/ClientConfigಗೂಗ್ಲಿಂಗ್ ಮಾಡಿದ ನಂತರ, ಹಡೂಪ್ ಹುಟ್ಟುವವರೆಗೂ ಸ್ಪಾರ್ಕ್ ನಿರೀಕ್ಷಿಸದಿರಲು ನಿರ್ಧರಿಸಿದೆ ಮತ್ತು ಜರ್ಸಿಯ ಹೊಸ ಆವೃತ್ತಿಯನ್ನು ಬಳಸಲು ನಿರ್ಧರಿಸಿದೆ ಎಂದು ನಾವು ಕಂಡುಕೊಂಡಿದ್ದೇವೆ. JIRA ನಲ್ಲಿ ಈ ವಿಷಯದ ಬಗ್ಗೆ ಅವರೇ ಪರಸ್ಪರ ವಾದಿಸುತ್ತಾರೆ. ಡೌನ್‌ಲೋಡ್ ಮಾಡುವುದು ಪರಿಹಾರವಾಗಿತ್ತು . ಇದನ್ನು SPARK_HOME ನಲ್ಲಿನ ಜಾರ್ ಫೋಲ್ಡರ್ನಲ್ಲಿ ಇರಿಸಿ, ಅದನ್ನು ಮತ್ತೆ ಜಿಪ್ ಮಾಡಿ ಮತ್ತು ಅದನ್ನು HDFS ಗೆ ಅಪ್‌ಲೋಡ್ ಮಾಡಿ.
ನಾವು ಈ ದೋಷವನ್ನು ಎದುರಿಸಿದ್ದೇವೆ, ಆದರೆ ಹೊಸ ಮತ್ತು ಸುವ್ಯವಸ್ಥಿತವಾದದ್ದು ಹುಟ್ಟಿಕೊಂಡಿತು.
org.apache.spark.SparkException: Yarn application has already ended! It might have been killed or unable to launch application masterಅದೇ ಸಮಯದಲ್ಲಿ, ನಾವು ಆವೃತ್ತಿ 2.0 ಅನ್ನು ಚಲಾಯಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತೇವೆ - ಎಲ್ಲವೂ ಸರಿಯಾಗಿದೆ. ಏನಾಗುತ್ತಿದೆ ಎಂದು ಊಹಿಸಲು ಪ್ರಯತ್ನಿಸಿ. ನಾವು ಈ ಅಪ್ಲಿಕೇಶನ್‌ನ ಲಾಗ್‌ಗಳನ್ನು ನೋಡಿದ್ದೇವೆ ಮತ್ತು ಈ ರೀತಿಯದನ್ನು ನೋಡಿದ್ದೇವೆ:
/usr/hdp/${hdp.version}/hadoop/lib/hadoop-lzo-0.6.0.${hdp.version}.jarಸಾಮಾನ್ಯವಾಗಿ, ಕೆಲವು ಕಾರಣಗಳಿಗಾಗಿ hdp.version ಪರಿಹರಿಸಲಿಲ್ಲ. ಗೂಗಲ್ ಮಾಡಿದ ನಂತರ, ನಾವು ಪರಿಹಾರವನ್ನು ಕಂಡುಕೊಂಡಿದ್ದೇವೆ. ನೀವು ಅಂಬಾರಿಯಲ್ಲಿನ YARN ಸೆಟ್ಟಿಂಗ್‌ಗಳಿಗೆ ಹೋಗಬೇಕು ಮತ್ತು ಕಸ್ಟಮ್ ನೂಲು-ಸೈಟ್‌ಗೆ ಪ್ಯಾರಾಮೀಟರ್ ಅನ್ನು ಸೇರಿಸಬೇಕು:
hdp.version=2.5.3.0-37ಈ ಮ್ಯಾಜಿಕ್ ಸಹಾಯ ಮಾಡಿತು, ಮತ್ತು ಸ್ಪಾರ್ಕ್ ಹೊರಟಿತು. ನಾವು ನಮ್ಮ ಹಲವಾರು ಜುಪಿಟರ್ ಲ್ಯಾಪ್‌ಟಾಪ್‌ಗಳನ್ನು ಪರೀಕ್ಷಿಸಿದ್ದೇವೆ. ಎಲ್ಲವೂ ಕೆಲಸ ಮಾಡುತ್ತಿದೆ. ನಾವು ಶನಿವಾರ (ನಾಳೆ) ಮೊದಲ ಸ್ಪಾರ್ಕ್ ಪಾಠಕ್ಕೆ ಸಿದ್ಧರಿದ್ದೇವೆ!
ಯುಪಿಡಿ. ಪಾಠದ ಸಮಯದಲ್ಲಿ, ಮತ್ತೊಂದು ಸಮಸ್ಯೆ ಬೆಳಕಿಗೆ ಬಂದಿತು. ಕೆಲವು ಹಂತದಲ್ಲಿ, ಸ್ಪಾರ್ಕ್‌ಗಾಗಿ ಧಾರಕಗಳನ್ನು ಒದಗಿಸುವುದನ್ನು YARN ನಿಲ್ಲಿಸಿತು. YARN ನಲ್ಲಿ ನಿಯತಾಂಕವನ್ನು ಸರಿಪಡಿಸುವುದು ಅಗತ್ಯವಾಗಿತ್ತು, ಇದು ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ 0.2 ಆಗಿತ್ತು:
yarn.scheduler.capacity.maximum-am-resource-percent=0.8
ಅಂದರೆ, ಸಂಪನ್ಮೂಲಗಳ ವಿತರಣೆಯಲ್ಲಿ ಕೇವಲ 20% ಸಂಪನ್ಮೂಲಗಳು ಭಾಗವಹಿಸಿವೆ. ನಿಯತಾಂಕಗಳನ್ನು ಬದಲಾಯಿಸಿದ ನಂತರ, ನಾವು YARN ಅನ್ನು ಮರುಲೋಡ್ ಮಾಡಿದ್ದೇವೆ. ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲಾಗಿದೆ ಮತ್ತು ಉಳಿದ ಭಾಗವಹಿಸುವವರು ಸ್ಪಾರ್ಕ್ ಸಂದರ್ಭವನ್ನು ಚಲಾಯಿಸಲು ಸಾಧ್ಯವಾಯಿತು.
ಮೂಲ: www.habr.com