ಅಪಾಚೆ NIFI - ಅಭ್ಯಾಸದಲ್ಲಿನ ವೈಶಿಷ್ಟ್ಯಗಳ ಸಂಕ್ಷಿಪ್ತ ಅವಲೋಕನ

ಪರಿಚಯ

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

ಉದ್ದೇಶ

3 ಸೇವೆಗಳನ್ನು ರಚಿಸಿ. ಅವುಗಳಲ್ಲಿ ಮೊದಲನೆಯದು ಡೇಟಾಬೇಸ್ ನವೀಕರಣ ಸೇವೆಯಾಗಿದೆ. ಈ ಸೇವೆಯು ಮೂರನೇ ವ್ಯಕ್ತಿಯ ಸಿಸ್ಟಮ್‌ನಿಂದ ಹೊಸ ಡೇಟಾ ಬಂದಾಗ, ಡೇಟಾಬೇಸ್‌ನಲ್ಲಿ ಡೇಟಾವನ್ನು ನವೀಕರಿಸುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಮುಂದಿನ ಸಿಸ್ಟಮ್‌ಗೆ ವರ್ಗಾಯಿಸಲು CSV ಸ್ವರೂಪದಲ್ಲಿ ಫೈಲ್ ಅನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ. ಎರಡನೇ ಸೇವೆಯ ಅಂತಿಮ ಬಿಂದುವನ್ನು ಕರೆಯಲಾಗುತ್ತದೆ - FTP ಸಾರಿಗೆ ಸೇವೆ, ವರ್ಗಾವಣೆಗೊಂಡ ಫೈಲ್ ಅನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ, ಅದನ್ನು ಮೌಲ್ಯೀಕರಿಸುತ್ತದೆ ಮತ್ತು FTP ಮೂಲಕ ಫೈಲ್ ಸಂಗ್ರಹಣೆಯಲ್ಲಿ ಇರಿಸುತ್ತದೆ. ಮೂರನೇ ಸೇವೆ, ಗ್ರಾಹಕ ಡೇಟಾ ವರ್ಗಾವಣೆ ಸೇವೆ, ಮೊದಲ ಎರಡರೊಂದಿಗೆ ಅಸಮಕಾಲಿಕವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ಮೇಲೆ ಚರ್ಚಿಸಿದ ಫೈಲ್ ಅನ್ನು ಸ್ವೀಕರಿಸಲು ಇದು ಮೂರನೇ ವ್ಯಕ್ತಿಯ ಬಾಹ್ಯ ವ್ಯವಸ್ಥೆಯಿಂದ ವಿನಂತಿಯನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ, ಸಿದ್ಧ ಪ್ರತಿಕ್ರಿಯೆ ಫೈಲ್ ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ, ಅದನ್ನು ಮಾರ್ಪಡಿಸುತ್ತದೆ (ಐಡಿ, ವಿವರಣೆ, ಲಿಂಕ್‌ಟೋಫೈಲ್ ಕ್ಷೇತ್ರಗಳನ್ನು ನವೀಕರಿಸುತ್ತದೆ) ಮತ್ತು ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು SOAP ಸಂದೇಶದ ರೂಪದಲ್ಲಿ ಕಳುಹಿಸುತ್ತದೆ. ಅಂದರೆ, ಒಟ್ಟಾರೆ ಚಿತ್ರವು ಈ ಕೆಳಗಿನಂತಿರುತ್ತದೆ: ಮೊದಲ ಎರಡು ಸೇವೆಗಳು ನವೀಕರಿಸಲು ಡೇಟಾ ಬಂದಾಗ ಮಾತ್ರ ತಮ್ಮ ಕೆಲಸವನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತವೆ. ಮೂರನೇ ಸೇವೆಯು ನಿರಂತರವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಏಕೆಂದರೆ ಮಾಹಿತಿಯ ಅನೇಕ ಗ್ರಾಹಕರು ಇದ್ದಾರೆ, ಪ್ರತಿ ನಿಮಿಷಕ್ಕೆ ಡೇಟಾಕ್ಕಾಗಿ ಸುಮಾರು 1000 ವಿನಂತಿಗಳು. ಸೇವೆಗಳು ನಿರಂತರವಾಗಿ ಲಭ್ಯವಿರುತ್ತವೆ ಮತ್ತು ಅವುಗಳ ನಿದರ್ಶನಗಳು ಪರೀಕ್ಷೆ, ಡೆಮೊ, ಪೂರ್ವ-ಉತ್ಪಾದನೆ ಮತ್ತು ಉತ್ಪನ್ನದಂತಹ ವಿಭಿನ್ನ ಪರಿಸರದಲ್ಲಿ ನೆಲೆಗೊಂಡಿವೆ. ಈ ಸೇವೆಗಳು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ ಎಂಬುದರ ರೇಖಾಚಿತ್ರವನ್ನು ಕೆಳಗೆ ನೀಡಲಾಗಿದೆ. ಅನಗತ್ಯ ಸಂಕೀರ್ಣತೆಯನ್ನು ತಪ್ಪಿಸಲು ಕೆಲವು ವಿವರಗಳನ್ನು ಸರಳೀಕರಿಸಲಾಗಿದೆ ಎಂದು ನಾನು ಈಗಿನಿಂದಲೇ ಸ್ಪಷ್ಟಪಡಿಸುತ್ತೇನೆ.

ತಾಂತ್ರಿಕ ಡೀಪನಿಂಗ್

ಸಮಸ್ಯೆಗೆ ಪರಿಹಾರವನ್ನು ಯೋಜಿಸುವಾಗ, ನಾವು ಮೊದಲು ಸ್ಪ್ರಿಂಗ್ ಫ್ರೇಮ್‌ವರ್ಕ್, Nginx balancer, Postgres ಡೇಟಾಬೇಸ್ ಮತ್ತು ಇತರ ತಾಂತ್ರಿಕ ಮತ್ತು ತಾಂತ್ರಿಕ ವಿಷಯಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಜಾವಾದಲ್ಲಿ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಮಾಡಲು ನಿರ್ಧರಿಸಿದ್ದೇವೆ. ತಾಂತ್ರಿಕ ಪರಿಹಾರವನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸುವ ಸಮಯವು ಈ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು ಇತರ ವಿಧಾನಗಳನ್ನು ಪರಿಗಣಿಸಲು ನಮಗೆ ಅವಕಾಶ ಮಾಡಿಕೊಟ್ಟಿದ್ದರಿಂದ, ನಮ್ಮ ನೋಟವು ಅಪಾಚೆ NIFI ತಂತ್ರಜ್ಞಾನದ ಮೇಲೆ ಬಿದ್ದಿತು, ಇದು ಕೆಲವು ವಲಯಗಳಲ್ಲಿ ಫ್ಯಾಶನ್ ಆಗಿದೆ. ಈ ತಂತ್ರಜ್ಞಾನವು ಈ 3 ಸೇವೆಗಳನ್ನು ಗಮನಿಸಲು ನಮಗೆ ಅವಕಾಶ ಮಾಡಿಕೊಟ್ಟಿದೆ ಎಂದು ನಾನು ಈಗಿನಿಂದಲೇ ಹೇಳುತ್ತೇನೆ. ಈ ಲೇಖನವು ಫೈಲ್ ಸಾರಿಗೆ ಸೇವೆಯ ಅಭಿವೃದ್ಧಿ ಮತ್ತು ಗ್ರಾಹಕರಿಗೆ ಡೇಟಾ ವರ್ಗಾವಣೆ ಸೇವೆಯನ್ನು ವಿವರಿಸುತ್ತದೆ, ಆದರೆ ಲೇಖನವು ಉಪಯುಕ್ತವಾಗಿದ್ದರೆ, ಡೇಟಾಬೇಸ್ನಲ್ಲಿ ಡೇಟಾವನ್ನು ನವೀಕರಿಸಲು ನಾನು ಸೇವೆಯ ಬಗ್ಗೆ ಬರೆಯುತ್ತೇನೆ.

ಅದು ಏನು?

NIFI ಎಂಬುದು ಡೇಟಾದ ವೇಗದ ಸಮಾನಾಂತರ ಲೋಡಿಂಗ್ ಮತ್ತು ಪ್ರಕ್ರಿಯೆಗಾಗಿ ವಿತರಿಸಲಾದ ವಾಸ್ತುಶಿಲ್ಪವಾಗಿದೆ, ಮೂಲಗಳು ಮತ್ತು ರೂಪಾಂತರಗಳಿಗಾಗಿ ಹೆಚ್ಚಿನ ಸಂಖ್ಯೆಯ ಪ್ಲಗಿನ್‌ಗಳು, ಸಂರಚನೆಗಳ ಆವೃತ್ತಿ ಮತ್ತು ಹೆಚ್ಚಿನವು. ಉತ್ತಮ ಬೋನಸ್ ಎಂದರೆ ಅದನ್ನು ಬಳಸಲು ತುಂಬಾ ಸುಲಭ. ಕ್ಷುಲ್ಲಕ ಪ್ರಕ್ರಿಯೆಗಳಾದ getFile, sendHttpRequest ಮತ್ತು ಇತರವುಗಳನ್ನು ಚೌಕಗಳಾಗಿ ಪ್ರತಿನಿಧಿಸಬಹುದು. ಪ್ರತಿಯೊಂದು ಚೌಕವು ಪ್ರಕ್ರಿಯೆಯನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ, ಅದರ ಪರಸ್ಪರ ಕ್ರಿಯೆಯನ್ನು ಕೆಳಗಿನ ಚಿತ್ರದಲ್ಲಿ ಕಾಣಬಹುದು. ಪ್ರಕ್ರಿಯೆಯ ಸೆಟಪ್ ಸಂವಹನಗಳ ಕುರಿತು ಹೆಚ್ಚು ವಿವರವಾದ ದಸ್ತಾವೇಜನ್ನು ಬರೆಯಲಾಗಿದೆ ಇಲ್ಲಿ , ರಷ್ಯನ್ ಮಾತನಾಡುವವರಿಗೆ - ಇಲ್ಲಿ. ದಸ್ತಾವೇಜನ್ನು NIFI ಅನ್ನು ಅನ್ಪ್ಯಾಕ್ ಮಾಡುವುದು ಮತ್ತು ರನ್ ಮಾಡುವುದು ಹೇಗೆ, ಹಾಗೆಯೇ ಚೌಕಗಳು ಎಂದೂ ಕರೆಯಲ್ಪಡುವ ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ಹೇಗೆ ರಚಿಸುವುದು ಎಂಬುದನ್ನು ವಿವರಿಸುತ್ತದೆ.
ಲೇಖನವನ್ನು ಬರೆಯುವ ಆಲೋಚನೆಯು ಸುದೀರ್ಘ ಹುಡುಕಾಟದ ನಂತರ ಹುಟ್ಟಿದೆ ಮತ್ತು ಸ್ವೀಕರಿಸಿದ ಮಾಹಿತಿಯನ್ನು ಪ್ರಜ್ಞಾಪೂರ್ವಕವಾಗಿ ರೂಪಿಸುತ್ತದೆ, ಜೊತೆಗೆ ಭವಿಷ್ಯದ ಡೆವಲಪರ್‌ಗಳಿಗೆ ಜೀವನವನ್ನು ಸ್ವಲ್ಪ ಸುಲಭಗೊಳಿಸುವ ಬಯಕೆ.

ಉದಾಹರಣೆಗೆ

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

ನೀವು ನೋಡುವಂತೆ, ಈ ಚಿತ್ರವು ಸಾಮಾನ್ಯ ಪ್ರಕ್ರಿಯೆಯನ್ನು ತೋರಿಸುತ್ತದೆ. HandleHttpRequest - ವಿನಂತಿಗಳನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ, ReplaceText - ಪ್ರತಿಕ್ರಿಯೆಯ ದೇಹವನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ, HandleHttpResponse - ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಕಳುಹಿಸುತ್ತದೆ. FetchFile - ಫೈಲ್ ಸಂಗ್ರಹಣೆಯಿಂದ ಫೈಲ್ ಅನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ, ಅದನ್ನು ಚೌಕಕ್ಕೆ ವರ್ಗಾಯಿಸುತ್ತದೆ PutSftp - ಈ ಫೈಲ್ ಅನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ವಿಳಾಸದಲ್ಲಿ FTP ನಲ್ಲಿ ಇರಿಸುತ್ತದೆ. ಈಗ ಈ ಪ್ರಕ್ರಿಯೆಯ ಬಗ್ಗೆ ಇನ್ನಷ್ಟು.

ಈ ಸಂದರ್ಭದಲ್ಲಿ, ವಿನಂತಿಯು ಎಲ್ಲದರ ಪ್ರಾರಂಭವಾಗಿದೆ. ಅದರ ಸಂರಚನಾ ನಿಯತಾಂಕಗಳನ್ನು ನೋಡೋಣ.

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

ಮುಂದೆ, ಚೌಕದ ReplaceText ಕಾನ್ಫಿಗರೇಶನ್ ನಿಯತಾಂಕಗಳನ್ನು ನೋಡೋಣ. ಬದಲಿ ಮೌಲ್ಯಕ್ಕೆ ಗಮನ ಕೊಡುವುದು ಯೋಗ್ಯವಾಗಿದೆ - ಇದು ಪ್ರತಿಕ್ರಿಯೆಯ ರೂಪದಲ್ಲಿ ಬಳಕೆದಾರರಿಗೆ ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಸೆಟ್ಟಿಂಗ್‌ಗಳಲ್ಲಿ ನೀವು ಲಾಗಿಂಗ್ ಮಟ್ಟವನ್ನು ಸರಿಹೊಂದಿಸಬಹುದು, ಲಾಗ್‌ಗಳನ್ನು {ನೀವು ಅನ್ಪ್ಯಾಕ್ ಮಾಡಿದ nifi}/nifi-1.9.2/logs ಅನ್ನು ನೀವು ನೋಡಬಹುದು, ವೈಫಲ್ಯ/ಯಶಸ್ಸಿನ ನಿಯತಾಂಕಗಳೂ ಇವೆ - ಈ ನಿಯತಾಂಕಗಳನ್ನು ಆಧರಿಸಿ ನೀವು ಪ್ರಕ್ರಿಯೆಯನ್ನು ಒಟ್ಟಾರೆಯಾಗಿ ನಿಯಂತ್ರಿಸಬಹುದು . ಅಂದರೆ, ಯಶಸ್ವಿ ಪಠ್ಯ ಸಂಸ್ಕರಣೆಯ ಸಂದರ್ಭದಲ್ಲಿ, ಬಳಕೆದಾರರಿಗೆ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಕಳುಹಿಸುವ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಕರೆಯಲಾಗುತ್ತದೆ, ಮತ್ತು ಇನ್ನೊಂದು ಸಂದರ್ಭದಲ್ಲಿ ನಾವು ವಿಫಲವಾದ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸರಳವಾಗಿ ಲಾಗ್ ಮಾಡುತ್ತೇವೆ.

ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಯಶಸ್ವಿಯಾಗಿ ರಚಿಸಿದಾಗ ಸ್ಥಿತಿಯನ್ನು ಹೊರತುಪಡಿಸಿ HandleHttpResponse ಗುಣಲಕ್ಷಣಗಳಲ್ಲಿ ವಿಶೇಷವಾಗಿ ಆಸಕ್ತಿದಾಯಕ ಏನೂ ಇಲ್ಲ.

ನಾವು ವಿನಂತಿ ಮತ್ತು ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ವಿಂಗಡಿಸಿದ್ದೇವೆ - ಫೈಲ್ ಅನ್ನು ಸ್ವೀಕರಿಸಲು ಮತ್ತು ಅದನ್ನು FTP ಸರ್ವರ್‌ನಲ್ಲಿ ಇರಿಸಲು ನಾವು ಹೋಗೋಣ. FetchFile - ಸೆಟ್ಟಿಂಗ್‌ಗಳಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಮಾರ್ಗದಲ್ಲಿ ಫೈಲ್ ಅನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಮುಂದಿನ ಪ್ರಕ್ರಿಯೆಗೆ ರವಾನಿಸುತ್ತದೆ.

ತದನಂತರ PutSftp ಚೌಕ - ಫೈಲ್ ಸಂಗ್ರಹಣೆಯಲ್ಲಿ ಫೈಲ್ ಅನ್ನು ಇರಿಸುತ್ತದೆ. ಕೆಳಗಿನ ಸಂರಚನಾ ನಿಯತಾಂಕಗಳನ್ನು ನಾವು ನೋಡಬಹುದು.

ಪ್ರತಿ ಚೌಕವು ಪ್ರತ್ಯೇಕ ಪ್ರಕ್ರಿಯೆಯಾಗಿದ್ದು ಅದನ್ನು ಪ್ರಾರಂಭಿಸಬೇಕು ಎಂಬ ಅಂಶಕ್ಕೆ ಗಮನ ಕೊಡುವುದು ಯೋಗ್ಯವಾಗಿದೆ. ಯಾವುದೇ ಸಂಕೀರ್ಣ ಗ್ರಾಹಕೀಕರಣ ಅಗತ್ಯವಿಲ್ಲದ ಸರಳ ಉದಾಹರಣೆಯನ್ನು ನಾವು ನೋಡಿದ್ದೇವೆ. ಮುಂದೆ, ನಾವು ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾಗಿ ನೋಡುತ್ತೇವೆ, ಅಲ್ಲಿ ನಾವು ಚಡಿಗಳ ಮೇಲೆ ಸ್ವಲ್ಪ ಬರೆಯುತ್ತೇವೆ.

ಹೆಚ್ಚು ಸಂಕೀರ್ಣ ಉದಾಹರಣೆ

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

ಇಲ್ಲಿ ಕಲ್ಪನೆಯು ವಿಶೇಷವಾಗಿ ಸಂಕೀರ್ಣವಾಗಿಲ್ಲ: ಗ್ರಾಹಕರಿಂದ ಡೇಟಾ ಅಗತ್ಯವಿದೆ ಎಂದು ನಾವು ವಿನಂತಿಯನ್ನು ಸ್ವೀಕರಿಸಿದ್ದೇವೆ, ಅವರು ಸಂದೇಶವನ್ನು ಸ್ವೀಕರಿಸಿದ್ದಾರೆ ಎಂದು ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಕಳುಹಿಸಿದ್ದಾರೆ, ಪ್ರತಿಕ್ರಿಯೆ ಫೈಲ್ ಅನ್ನು ಸ್ವೀಕರಿಸುವ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಪ್ರಾರಂಭಿಸಿದರು, ನಂತರ ಅದನ್ನು ನಿರ್ದಿಷ್ಟ ತರ್ಕದೊಂದಿಗೆ ಸಂಪಾದಿಸಿ, ಮತ್ತು ನಂತರ ಫೈಲ್ ಅನ್ನು ಗ್ರಾಹಕರಿಗೆ SOAP ಸಂದೇಶದ ರೂಪದಲ್ಲಿ ಸರ್ವರ್‌ಗೆ ವರ್ಗಾಯಿಸಿದೆ.

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

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

import org.apache.commons.io.IOUtils
import groovy.xml.XmlUtil
import java.nio.charset.*
import groovy.xml.StreamingMarkupBuilder

def flowFile = session.get()
if (!flowFile) return
try {
    flowFile = session.write(flowFile, { inputStream, outputStream ->
        String result = IOUtils.toString(inputStream, "UTF-8");
        def recordIn = new XmlSlurper().parseText(result)
        def element = recordIn.depthFirst().find {
            it.name() == 'id'
        }

        def newId = Integer.parseInt(element.toString()) + 1
        def recordOut = new XmlSlurper().parseText(result)
        recordOut.Body.ClientMessage.RequestMessage.RequestContent.content.MessagePrimaryContent.ResponseBody.id = newId

        def res = new StreamingMarkupBuilder().bind { mkp.yield recordOut }.toString()
        outputStream.write(res.getBytes(StandardCharsets.UTF_8))
} as StreamCallback)
     session.transfer(flowFile, REL_SUCCESS)
}
catch(Exception e) {
    log.error("Error during processing of validate.groovy", e)
    session.transfer(flowFile, REL_FAILURE)
}

ವಾಸ್ತವವಾಗಿ, ಇಲ್ಲಿಯೇ ಚೌಕದ ಗ್ರಾಹಕೀಕರಣವು ಕೊನೆಗೊಳ್ಳುತ್ತದೆ. ಮುಂದೆ, ನವೀಕರಿಸಿದ ಫೈಲ್ ಅನ್ನು ಚೌಕಕ್ಕೆ ವರ್ಗಾಯಿಸಲಾಗುತ್ತದೆ, ಇದು ಫೈಲ್ ಅನ್ನು ಸರ್ವರ್ಗೆ ಕಳುಹಿಸಲು ಕಾರಣವಾಗಿದೆ. ಈ ಚೌಕದ ಸೆಟ್ಟಿಂಗ್‌ಗಳನ್ನು ಕೆಳಗೆ ನೀಡಲಾಗಿದೆ.

SOAP ಸಂದೇಶವನ್ನು ರವಾನಿಸುವ ವಿಧಾನವನ್ನು ನಾವು ವಿವರಿಸುತ್ತೇವೆ. ನಾವು ಎಲ್ಲಿ ಬರೆಯುತ್ತೇವೆ. ಮುಂದೆ ನೀವು ಇದನ್ನು SOAP ಎಂದು ಸೂಚಿಸಬೇಕು.

ಹೋಸ್ಟ್ ಮತ್ತು ಆಕ್ಷನ್ (ಸೋಪ್ ಆಕ್ಷನ್) ನಂತಹ ಹಲವಾರು ಗುಣಲಕ್ಷಣಗಳನ್ನು ಸೇರಿಸಿ. ನಾವು ಉಳಿಸುತ್ತೇವೆ ಮತ್ತು ಪರಿಶೀಲಿಸುತ್ತೇವೆ. SOAP ವಿನಂತಿಗಳನ್ನು ಹೇಗೆ ಕಳುಹಿಸುವುದು ಎಂಬುದರ ಕುರಿತು ಹೆಚ್ಚಿನ ವಿವರಗಳನ್ನು ನೀವು ನೋಡಬಹುದು ಇಲ್ಲಿ

NIFI ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ಬಳಸುವ ಹಲವಾರು ಆಯ್ಕೆಗಳನ್ನು ನಾವು ನೋಡಿದ್ದೇವೆ. ಅವರು ಹೇಗೆ ಸಂವಹನ ನಡೆಸುತ್ತಾರೆ ಮತ್ತು ಅವರ ನಿಜವಾದ ಪ್ರಯೋಜನವೇನು? ಪರಿಗಣಿಸಲಾದ ಉದಾಹರಣೆಗಳು ಪರೀಕ್ಷೆಗಳಾಗಿವೆ ಮತ್ತು ಯುದ್ಧದಲ್ಲಿ ನಿಜವಾಗಿ ಏನಾಗುತ್ತದೆ ಎಂಬುದರಲ್ಲಿ ಸ್ವಲ್ಪ ಭಿನ್ನವಾಗಿರುತ್ತವೆ. ಈ ಲೇಖನವು ಡೆವಲಪರ್‌ಗಳಿಗೆ ಸ್ವಲ್ಪ ಉಪಯುಕ್ತವಾಗಿದೆ ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ. ನಿಮ್ಮ ಗಮನಕ್ಕೆ ಧನ್ಯವಾದಗಳು. ನೀವು ಯಾವುದೇ ಪ್ರಶ್ನೆಗಳನ್ನು ಹೊಂದಿದ್ದರೆ, ಬರೆಯಿರಿ. ನಾನು ಉತ್ತರಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತೇನೆ.

ಮೂಲ: www.habr.com