ಎಲ್ಲರೂ ಹಲೋ!

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

NiFi ಸೈಟ್‌ನಿಂದ ಸೈಟ್ (S2S) ಎಂಬುದು NiFi ನಿದರ್ಶನಗಳ ನಡುವೆ ಡೇಟಾವನ್ನು ವರ್ಗಾಯಿಸಲು ಸುರಕ್ಷಿತ, ಹೆಚ್ಚು ಗ್ರಾಹಕೀಯಗೊಳಿಸಬಹುದಾದ ಮಾರ್ಗವಾಗಿದೆ. S2S ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ನೋಡಿ ದಸ್ತಾವೇಜನ್ನು ಮತ್ತು S2S ನೋಡಲು ಅನುಮತಿಸಲು ನಿಮ್ಮ NiFi ನಿದರ್ಶನವನ್ನು ಹೊಂದಿಸಲು ನೆನಪಿಟ್ಟುಕೊಳ್ಳುವುದು ಮುಖ್ಯವಾಗಿದೆ ಇಲ್ಲಿ.

S2S ಬಳಸಿಕೊಂಡು ಡೇಟಾ ವರ್ಗಾವಣೆಗೆ ಬಂದಾಗ, ಒಂದು ನಿದರ್ಶನವನ್ನು ಕ್ಲೈಂಟ್ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ, ಎರಡನೆಯದು ಸರ್ವರ್ ಆಗಿದೆ. ಕ್ಲೈಂಟ್ ಡೇಟಾವನ್ನು ಕಳುಹಿಸುತ್ತದೆ, ಸರ್ವರ್ ಅದನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ. ಅವುಗಳ ನಡುವೆ ಡೇಟಾ ವರ್ಗಾವಣೆಯನ್ನು ಹೊಂದಿಸಲು ಎರಡು ಮಾರ್ಗಗಳು:

1. ಪುಶ್. ರಿಮೋಟ್ ಪ್ರೊಸೆಸ್ ಗ್ರೂಪ್ (RPG) ಬಳಸಿಕೊಂಡು ಕ್ಲೈಂಟ್ ನಿದರ್ಶನದಿಂದ ಡೇಟಾವನ್ನು ಕಳುಹಿಸಲಾಗುತ್ತದೆ. ಸರ್ವರ್ ನಿದರ್ಶನದಲ್ಲಿ, ಇನ್‌ಪುಟ್ ಪೋರ್ಟ್ ಬಳಸಿ ಡೇಟಾವನ್ನು ಸ್ವೀಕರಿಸಲಾಗುತ್ತದೆ
2. ಪುಲ್. ಸರ್ವರ್ RPG ಬಳಸಿಕೊಂಡು ಡೇಟಾವನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ, ಕ್ಲೈಂಟ್ ಔಟ್ಪುಟ್ ಪೋರ್ಟ್ ಬಳಸಿ ಕಳುಹಿಸುತ್ತದೆ.

ರೋಲಿಂಗ್ಗಾಗಿ ಹರಿವನ್ನು ಅಪಾಚೆ ರಿಜಿಸ್ಟ್ರಿಯಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗಿದೆ.

Apache NiFi ರಿಜಿಸ್ಟ್ರಿಯು Apache NiFi ನ ಉಪಯೋಜನೆಯಾಗಿದ್ದು ಅದು ಹರಿವಿನ ಸಂಗ್ರಹಣೆ ಮತ್ತು ಆವೃತ್ತಿಯ ಸಾಧನವನ್ನು ಒದಗಿಸುತ್ತದೆ. ಒಂದು ರೀತಿಯ GIT. ನೋಂದಾವಣೆಯೊಂದಿಗೆ ಸ್ಥಾಪಿಸುವುದು, ಕಾನ್ಫಿಗರ್ ಮಾಡುವುದು ಮತ್ತು ಕೆಲಸ ಮಾಡುವ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಕಾಣಬಹುದು ಅಧಿಕೃತ ದಸ್ತಾವೇಜನ್ನು. ಶೇಖರಣೆಗಾಗಿ ಫ್ಲೋ ಅನ್ನು ಪ್ರಕ್ರಿಯೆಯ ಗುಂಪಿನಲ್ಲಿ ಸಂಯೋಜಿಸಲಾಗಿದೆ ಮತ್ತು ಈ ರೂಪದಲ್ಲಿ ನೋಂದಾವಣೆಯಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ. ನಾವು ಇದನ್ನು ನಂತರ ಲೇಖನದಲ್ಲಿ ಹಿಂತಿರುಗಿಸುತ್ತೇವೆ.

ಪ್ರಾರಂಭದಲ್ಲಿ, N ಒಂದು ಸಣ್ಣ ಸಂಖ್ಯೆಯಾಗಿದ್ದಾಗ, ಹರಿವನ್ನು ಸಮಂಜಸವಾದ ಸಮಯದಲ್ಲಿ ಕೈಯಿಂದ ವಿತರಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ನವೀಕರಿಸಲಾಗುತ್ತದೆ.

ಆದರೆ N ಬೆಳೆದಂತೆ, ಹೆಚ್ಚಿನ ಸಮಸ್ಯೆಗಳಿವೆ:

1. ಹರಿವನ್ನು ನವೀಕರಿಸಲು ಹೆಚ್ಚು ಸಮಯ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. ನೀವು ಎಲ್ಲಾ ಸರ್ವರ್‌ಗಳಿಗೆ ಹೋಗಬೇಕಾಗಿದೆ
2. ಟೆಂಪ್ಲೇಟ್‌ಗಳನ್ನು ನವೀಕರಿಸುವಲ್ಲಿ ದೋಷಗಳಿವೆ. ಇಲ್ಲಿ ಅವರು ನವೀಕರಿಸಿದ್ದಾರೆ, ಆದರೆ ಇಲ್ಲಿ ಅವರು ಮರೆತಿದ್ದಾರೆ
3. ಹೆಚ್ಚಿನ ಸಂಖ್ಯೆಯ ಒಂದೇ ರೀತಿಯ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿರ್ವಹಿಸುವಾಗ ಮಾನವ ದೋಷ

ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸುವುದು ಅವಶ್ಯಕ ಎಂಬ ಅಂಶಕ್ಕೆ ಇದೆಲ್ಲವೂ ನಮ್ಮನ್ನು ತರುತ್ತದೆ. ಈ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು ನಾನು ಈ ಕೆಳಗಿನ ವಿಧಾನಗಳನ್ನು ಪ್ರಯತ್ನಿಸಿದೆ:

1. NiFi ಬದಲಿಗೆ MiNiFi ಬಳಸಿ
2. NiFi CLI
3. NiPyAPI

MiNiFi ಬಳಸುವುದು

ApacheMiNify Apache NiFi ನ ಉಪಯೋಜನೆಯಾಗಿದೆ. MiNiFy ಒಂದು ಕಾಂಪ್ಯಾಕ್ಟ್ ಏಜೆಂಟ್ ಆಗಿದ್ದು ಅದು NiFi ಯಂತೆಯೇ ಅದೇ ಪ್ರೊಸೆಸರ್‌ಗಳನ್ನು ಬಳಸುತ್ತದೆ, ಇದು NiFi ನಲ್ಲಿರುವಂತೆ ಅದೇ ಹರಿವನ್ನು ರಚಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಮಿನಿಫೈ ಫ್ಲೋ ಕಾನ್ಫಿಗರೇಶನ್‌ಗಾಗಿ ಗ್ರಾಫಿಕಲ್ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಹೊಂದಿಲ್ಲ ಎಂಬ ಕಾರಣದಿಂದಾಗಿ ಏಜೆಂಟ್‌ನ ಲಘುತೆಯನ್ನು ಇತರ ವಿಷಯಗಳ ಜೊತೆಗೆ ಸಾಧಿಸಲಾಗುತ್ತದೆ. MiNiFy ನ ಚಿತ್ರಾತ್ಮಕ ಇಂಟರ್ಫೇಸ್ ಕೊರತೆ ಎಂದರೆ minifi ನಲ್ಲಿ ಹರಿವಿನ ವಿತರಣೆಯ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು ಇದು ಅವಶ್ಯಕವಾಗಿದೆ. MiNiFy ಅನ್ನು IOT ನಲ್ಲಿ ಸಕ್ರಿಯವಾಗಿ ಬಳಸಲಾಗಿರುವುದರಿಂದ, ಹಲವು ಘಟಕಗಳಿವೆ ಮತ್ತು ಅಂತಿಮ ಮಿನಿಫೈ ನಿದರ್ಶನಗಳಿಗೆ ಹರಿವನ್ನು ತಲುಪಿಸುವ ಪ್ರಕ್ರಿಯೆಯು ಸ್ವಯಂಚಾಲಿತವಾಗಿರಬೇಕು. ಒಂದು ಪರಿಚಿತ ಕಾರ್ಯ, ಸರಿ?

ಮತ್ತೊಂದು ಉಪಪ್ರಾಜೆಕ್ಟ್, MiNiFi C2 ಸರ್ವರ್, ಈ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಈ ಉತ್ಪನ್ನವು ನಿಯೋಜನೆ ಆರ್ಕಿಟೆಕ್ಚರ್‌ನಲ್ಲಿ ಕೇಂದ್ರ ಬಿಂದುವಾಗಿರಲು ಉದ್ದೇಶಿಸಲಾಗಿದೆ. ಪರಿಸರವನ್ನು ಹೇಗೆ ಕಾನ್ಫಿಗರ್ ಮಾಡುವುದು - ವಿವರಿಸಲಾಗಿದೆ ಈ ಲೇಖನ ಹಬ್ರೆಯಲ್ಲಿ ಮತ್ತು ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು ಮಾಹಿತಿಯು ಸಾಕು. C2 ಸರ್ವರ್‌ನೊಂದಿಗೆ MiNiFi ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಅದರ ಸಂರಚನೆಯನ್ನು ನವೀಕರಿಸುತ್ತದೆ. ಈ ವಿಧಾನದ ಏಕೈಕ ನ್ಯೂನತೆಯೆಂದರೆ ನೀವು C2 ಸರ್ವರ್‌ನಲ್ಲಿ ಟೆಂಪ್ಲೆಟ್ಗಳನ್ನು ರಚಿಸಬೇಕಾಗಿದೆ, ನೋಂದಾವಣೆಗೆ ಸರಳವಾದ ಬದ್ಧತೆ ಸಾಕಾಗುವುದಿಲ್ಲ.

ಮೇಲಿನ ಲೇಖನದಲ್ಲಿ ವಿವರಿಸಿದ ಆಯ್ಕೆಯು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿದೆ ಮತ್ತು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಕಷ್ಟವಾಗುವುದಿಲ್ಲ, ಆದರೆ ನಾವು ಈ ಕೆಳಗಿನವುಗಳನ್ನು ಮರೆಯಬಾರದು:

1. minifi nifi ನಿಂದ ಎಲ್ಲಾ ಪ್ರೊಸೆಸರ್‌ಗಳನ್ನು ಹೊಂದಿಲ್ಲ
2. Minifi ನಲ್ಲಿರುವ CPU ಆವೃತ್ತಿಗಳು NiFi ನಲ್ಲಿ CPU ಆವೃತ್ತಿಗಳಿಗಿಂತ ಹಿಂದುಳಿದಿವೆ.

ಬರೆಯುವ ಸಮಯದಲ್ಲಿ, NiFi ನ ಇತ್ತೀಚಿನ ಆವೃತ್ತಿಯು 1.9.2 ಆಗಿದೆ. ಇತ್ತೀಚಿನ MiNiFi ಆವೃತ್ತಿಯ ಪ್ರೊಸೆಸರ್ ಆವೃತ್ತಿ 1.7.0 ಆಗಿದೆ. MiNiFi ಗೆ ಪ್ರೊಸೆಸರ್‌ಗಳನ್ನು ಸೇರಿಸಬಹುದು, ಆದರೆ NiFi ಮತ್ತು MiNiFi ಪ್ರೊಸೆಸರ್‌ಗಳ ನಡುವಿನ ಆವೃತ್ತಿಯ ವ್ಯತ್ಯಾಸಗಳಿಂದಾಗಿ ಇದು ಕಾರ್ಯನಿರ್ವಹಿಸದೇ ಇರಬಹುದು.

NiFi CLI

ಇವರಿಂದ ನಿರ್ಣಯಿಸುವುದು ವಿವರಣೆ ಅಧಿಕೃತ ವೆಬ್‌ಸೈಟ್‌ನಲ್ಲಿನ ಸಾಧನ, ಇದು ಹರಿವಿನ ವಿತರಣೆ ಅಥವಾ ಪ್ರಕ್ರಿಯೆ ನಿರ್ವಹಣೆಯ ಕ್ಷೇತ್ರದಲ್ಲಿ NiFI ಮತ್ತು NiFi ರಿಜಿಸ್ಟ್ರಿಯ ನಡುವಿನ ಪರಸ್ಪರ ಕ್ರಿಯೆಯನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸುವ ಸಾಧನವಾಗಿದೆ. ಪ್ರಾರಂಭಿಸಲು ಈ ಉಪಕರಣವನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡಿ. ಇಲ್ಲಿಂದ.

ಉಪಯುಕ್ತತೆಯನ್ನು ರನ್ ಮಾಡಿ

./bin/cli.sh
           _     ___  _
 Apache   (_)  .' ..](_)   ,
 _ .--.   __  _| |_  __    )
[ `.-. | [  |'-| |-'[  |  /  
|  | | |  | |  | |   | | '    '
[___||__][___][___] [___]',  ,'
                           `'
          CLI v1.9.2

Type 'help' to see a list of available commands, use tab to auto-complete.

ನಾವು ನೋಂದಾವಣೆಯಿಂದ ಅಗತ್ಯವಾದ ಹರಿವನ್ನು ಲೋಡ್ ಮಾಡಲು, ನಾವು ಬ್ಯಾಸ್ಕೆಟ್ನ ಗುರುತಿಸುವಿಕೆಗಳನ್ನು (ಬಕೆಟ್ ಗುರುತಿಸುವಿಕೆ) ಮತ್ತು ಹರಿವು ಸ್ವತಃ (ಫ್ಲೋ ಐಡೆಂಟಿಫೈಯರ್) ತಿಳಿದುಕೊಳ್ಳಬೇಕು. ಈ ಡೇಟಾವನ್ನು cli ಮೂಲಕ ಅಥವಾ NiFi ರಿಜಿಸ್ಟ್ರಿ ವೆಬ್ ಇಂಟರ್ಫೇಸ್ನಲ್ಲಿ ಪಡೆಯಬಹುದು. ವೆಬ್ ಇಂಟರ್ಫೇಸ್ ಈ ರೀತಿ ಕಾಣುತ್ತದೆ:

CLI ಬಳಸಿ, ನೀವು ಇದನ್ನು ಮಾಡಿ:

#> registry list-buckets -u http://nifi-registry:18080

#   Name             Id                                     Description
-   --------------   ------------------------------------   -----------
1   test_bucket   709d387a-9ce9-4535-8546-3621efe38e96   (empty)

#> registry list-flows -b 709d387a-9ce9-4535-8546-3621efe38e96 -u http://nifi-registry:18080

#   Name           Id                                     Description
-   ------------   ------------------------------------   -----------
1   test_flow   d27af00a-5b47-4910-89cd-9c664cd91e85

ನೋಂದಾವಣೆಯಿಂದ ಆಮದು ಪ್ರಕ್ರಿಯೆ ಗುಂಪನ್ನು ರನ್ ಮಾಡಿ:

#> nifi pg-import -b 709d387a-9ce9-4535-8546-3621efe38e96 -f d27af00a-5b47-4910-89cd-9c664cd91e85 -fv 1 -u http://nifi:8080

7f522a13-016e-1000-e504-d5b15587f2f3

ಒಂದು ಪ್ರಮುಖ ಅಂಶವೆಂದರೆ ಯಾವುದೇ ನಿಫೈ ನಿದರ್ಶನವನ್ನು ನಾವು ಪ್ರಕ್ರಿಯೆ ಗುಂಪನ್ನು ರೋಲ್ ಮಾಡುವ ಹೋಸ್ಟ್‌ನಂತೆ ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು.

ನಿಲ್ಲಿಸಿದ ಪ್ರೊಸೆಸರ್‌ಗಳೊಂದಿಗೆ ಪ್ರಕ್ರಿಯೆ ಗುಂಪನ್ನು ಸೇರಿಸಲಾಗಿದೆ, ಅವುಗಳನ್ನು ಪ್ರಾರಂಭಿಸಬೇಕಾಗಿದೆ

#> nifi pg-start -pgid 7f522a13-016e-1000-e504-d5b15587f2f3 -u http://nifi:8080

ಅದ್ಭುತವಾಗಿದೆ, ಪ್ರೊಸೆಸರ್‌ಗಳು ಪ್ರಾರಂಭವಾಗಿವೆ. ಆದಾಗ್ಯೂ, ಸಮಸ್ಯೆಯ ಪರಿಸ್ಥಿತಿಗಳ ಪ್ರಕಾರ, ಇತರ ನಿದರ್ಶನಗಳಿಗೆ ಡೇಟಾವನ್ನು ಕಳುಹಿಸಲು ನಮಗೆ NiFi ನಿದರ್ಶನಗಳ ಅಗತ್ಯವಿದೆ. ಸರ್ವರ್‌ಗೆ ಡೇಟಾವನ್ನು ವರ್ಗಾಯಿಸಲು ಪುಶ್ ವಿಧಾನವನ್ನು ಆಯ್ಕೆ ಮಾಡಲಾಗಿದೆ ಎಂದು ಭಾವಿಸೋಣ. ಡೇಟಾ ವರ್ಗಾವಣೆಯನ್ನು ಸಂಘಟಿಸಲು, ನಮ್ಮ ಹರಿವಿನಲ್ಲಿ ಈಗಾಗಲೇ ಸೇರಿಸಲಾದ ರಿಮೋಟ್ ಪ್ರೊಸೆಸ್ ಗ್ರೂಪ್ (RPG) ನಲ್ಲಿ ಡೇಟಾ ವರ್ಗಾವಣೆಯನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುವುದು (ಪ್ರಸರಣವನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುವುದು) ಅಗತ್ಯವಾಗಿದೆ.

CLI ಮತ್ತು ಇತರ ಮೂಲಗಳಲ್ಲಿನ ದಾಖಲಾತಿಯಲ್ಲಿ, ಡೇಟಾ ವರ್ಗಾವಣೆಯನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುವ ಮಾರ್ಗವನ್ನು ನಾನು ಕಂಡುಹಿಡಿಯಲಿಲ್ಲ. ಇದನ್ನು ಹೇಗೆ ಮಾಡಬೇಕೆಂದು ನಿಮಗೆ ತಿಳಿದಿದ್ದರೆ, ದಯವಿಟ್ಟು ಕಾಮೆಂಟ್ಗಳಲ್ಲಿ ಬರೆಯಿರಿ.

ನಾವು ಬ್ಯಾಷ್ ಹೊಂದಿರುವುದರಿಂದ ಮತ್ತು ನಾವು ಅಂತ್ಯಕ್ಕೆ ಹೋಗಲು ಸಿದ್ಧರಿರುವುದರಿಂದ, ನಾವು ಒಂದು ಮಾರ್ಗವನ್ನು ಕಂಡುಕೊಳ್ಳುತ್ತೇವೆ! ಈ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು ನೀವು NiFi API ಅನ್ನು ಬಳಸಬಹುದು. ಕೆಳಗಿನ ವಿಧಾನವನ್ನು ಬಳಸೋಣ, ಮೇಲಿನ ಉದಾಹರಣೆಗಳಿಂದ ನಾವು ID ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತೇವೆ (ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ ಇದು 7f522a13-016e-1000-e504-d5b15587f2f3). NiFi API ವಿಧಾನಗಳ ವಿವರಣೆ ಇಲ್ಲಿ.

ದೇಹದಲ್ಲಿ, ನೀವು ಈ ಕೆಳಗಿನ ಫಾರ್ಮ್‌ನ JSON ಅನ್ನು ಪಾಸ್ ಮಾಡಬೇಕಾಗಿದೆ:

{
    "revision": {
	    "clientId": "value",
	    "version": 0,
	    "lastModifier": "value"
	},
    "state": "value",
    "disconnectedNodeAcknowledged": true
}

"ಕೆಲಸ" ಮಾಡಲು ಭರ್ತಿ ಮಾಡಬೇಕಾದ ನಿಯತಾಂಕಗಳು:
ರಾಜ್ಯ - ಡೇಟಾ ವರ್ಗಾವಣೆ ಸ್ಥಿತಿ. ಡೇಟಾ ವರ್ಗಾವಣೆಯನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಲು ಟ್ರಾನ್ಸ್‌ಮಿಟಿಂಗ್ ಲಭ್ಯವಿದೆ, ನಿಷ್ಕ್ರಿಯಗೊಳಿಸಲು ನಿಲ್ಲಿಸಲಾಗಿದೆ
ಆವೃತ್ತಿ - ಪ್ರೊಸೆಸರ್ ಆವೃತ್ತಿ

ರಚಿಸಿದಾಗ ಆವೃತ್ತಿಯು ಡೀಫಾಲ್ಟ್ ಆಗಿರುತ್ತದೆ, ಆದರೆ ಈ ನಿಯತಾಂಕಗಳನ್ನು ವಿಧಾನವನ್ನು ಬಳಸಿಕೊಂಡು ಪಡೆಯಬಹುದು

ಬ್ಯಾಷ್ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳ ಪ್ರಿಯರಿಗೆ, ಈ ವಿಧಾನವು ಸೂಕ್ತವೆಂದು ತೋರುತ್ತದೆ, ಆದರೆ ಇದು ನನಗೆ ಕಷ್ಟ - ಬ್ಯಾಷ್ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳು ನನ್ನ ನೆಚ್ಚಿನದಲ್ಲ. ಮುಂದಿನ ಮಾರ್ಗವು ನನ್ನ ಅಭಿಪ್ರಾಯದಲ್ಲಿ ಹೆಚ್ಚು ಆಸಕ್ತಿದಾಯಕ ಮತ್ತು ಹೆಚ್ಚು ಅನುಕೂಲಕರವಾಗಿದೆ.

NiPyAPI

NiPyAPI ಎಂಬುದು NiFi ನಿದರ್ಶನಗಳೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸಲು ಪೈಥಾನ್ ಲೈಬ್ರರಿಯಾಗಿದೆ. ಡಾಕ್ಯುಮೆಂಟೇಶನ್ ಪುಟ ಗ್ರಂಥಾಲಯದೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಅಗತ್ಯವಾದ ಮಾಹಿತಿಯನ್ನು ಒಳಗೊಂಡಿದೆ. ತ್ವರಿತ ಪ್ರಾರಂಭವನ್ನು ವಿವರಿಸಲಾಗಿದೆ ಕರಡು ಗಿಥಬ್ ಮೇಲೆ.

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

nipyapi.config.nifi_config.host = 'http://nifi:8080/nifi-api' #путь до nifi-api инстанса, на котором разворачиваем process group
nipyapi.config.registry_config.host = 'http://nifi-registry:18080/nifi-registry-api' #путь до nifi-registry-api registry
nipyapi.config.registry_name = 'MyBeutifulRegistry' #название registry, как будет называться в инстансе nifi
nipyapi.config.bucket_name = 'BucketName' #название bucket, из которого подтягиваем flow
nipyapi.config.flow_name = 'FlowName' #название flow, которое подтягиваем

ಮುಂದೆ ನಾನು ವಿವರಿಸಿರುವ ಈ ಗ್ರಂಥಾಲಯದ ವಿಧಾನಗಳ ಹೆಸರುಗಳನ್ನು ಸೇರಿಸುತ್ತೇನೆ ಇಲ್ಲಿ.

ನಾವು ರಿಜಿಸ್ಟ್ರಿಯನ್ನು ಬಳಸಿ ನಿಫೈ ನಿದರ್ಶನಕ್ಕೆ ಸಂಪರ್ಕಿಸುತ್ತೇವೆ

nipyapi.versioning.create_registry_client

ಈ ಹಂತದಲ್ಲಿ, ನೋಂದಾವಣೆಯನ್ನು ಈಗಾಗಲೇ ನಿದರ್ಶನಕ್ಕೆ ಸೇರಿಸಲಾಗಿದೆಯೇ ಎಂಬ ಚೆಕ್ ಅನ್ನು ಸಹ ನೀವು ಸೇರಿಸಬಹುದು, ಇದಕ್ಕಾಗಿ ನೀವು ವಿಧಾನವನ್ನು ಬಳಸಬಹುದು

nipyapi.versioning.list_registry_clients

ಬುಟ್ಟಿಯಲ್ಲಿನ ಹರಿವನ್ನು ಮತ್ತಷ್ಟು ಹುಡುಕಲು ನಾವು ಬಕೆಟ್ ಅನ್ನು ಕಂಡುಕೊಳ್ಳುತ್ತೇವೆ

nipyapi.versioning.get_registry_bucket

ಕಂಡುಬಂದ ಬಕೆಟ್ ಪ್ರಕಾರ, ನಾವು ಹರಿವನ್ನು ಹುಡುಕುತ್ತಿದ್ದೇವೆ

nipyapi.versioning.get_flow_in_bucket

ಮುಂದೆ, ಈ ಪ್ರಕ್ರಿಯೆಯ ಗುಂಪನ್ನು ಈಗಾಗಲೇ ಸೇರಿಸಲಾಗಿದೆಯೇ ಎಂದು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಮುಖ್ಯವಾಗಿದೆ. ಪ್ರಕ್ರಿಯೆಯ ಗುಂಪನ್ನು ನಿರ್ದೇಶಾಂಕಗಳಿಂದ ಇರಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಎರಡನೆಯದನ್ನು ಒಂದರ ಮೇಲೆ ಅತಿಕ್ರಮಿಸಿದಾಗ ಪರಿಸ್ಥಿತಿ ಉದ್ಭವಿಸಬಹುದು. ನಾನು ಪರಿಶೀಲಿಸಿದ್ದೇನೆ, ಅದು ಆಗಿರಬಹುದು 🙂 ಎಲ್ಲಾ ಸೇರಿಸಿದ ಪ್ರಕ್ರಿಯೆ ಗುಂಪನ್ನು ಪಡೆಯಲು, ವಿಧಾನವನ್ನು ಬಳಸಿ

nipyapi.canvas.list_all_process_groups

ಮತ್ತು ನಂತರ ನಾವು ಹುಡುಕಬಹುದು, ಉದಾಹರಣೆಗೆ, ಹೆಸರಿನಿಂದ.

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

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

nipyapi.versioning.get_latest_flow_ver

ಪ್ರಕ್ರಿಯೆ ಗುಂಪನ್ನು ನಿಯೋಜಿಸಿ:

nipyapi.versioning.deploy_flow_version

ನಾವು ಪ್ರೊಸೆಸರ್ಗಳನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ:

nipyapi.canvas.schedule_process_group

CLI ಬಗ್ಗೆ ಬ್ಲಾಕ್ನಲ್ಲಿ, ರಿಮೋಟ್ ಪ್ರಕ್ರಿಯೆ ಗುಂಪಿನಲ್ಲಿ ಡೇಟಾ ವರ್ಗಾವಣೆಯನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಸಕ್ರಿಯಗೊಳಿಸಲಾಗಿಲ್ಲ ಎಂದು ಬರೆಯಲಾಗಿದೆಯೇ? ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವಾಗ, ನಾನು ಸಹ ಈ ಸಮಸ್ಯೆಯನ್ನು ಎದುರಿಸಿದೆ. ಆ ಸಮಯದಲ್ಲಿ, ನಾನು API ಬಳಸಿಕೊಂಡು ಡೇಟಾ ವರ್ಗಾವಣೆಯನ್ನು ಪ್ರಾರಂಭಿಸಲು ಸಾಧ್ಯವಾಗಲಿಲ್ಲ ಮತ್ತು ನಾನು NiPyAPI ಲೈಬ್ರರಿಯ ಡೆವಲಪರ್‌ಗೆ ಬರೆಯಲು ಮತ್ತು ಸಲಹೆ / ಸಹಾಯವನ್ನು ಕೇಳಲು ನಿರ್ಧರಿಸಿದೆ. ಡೆವಲಪರ್ ನನಗೆ ಉತ್ತರಿಸಿದರು, ನಾವು ಸಮಸ್ಯೆಯನ್ನು ಚರ್ಚಿಸಿದ್ದೇವೆ ಮತ್ತು ಅವರು "ಏನನ್ನಾದರೂ ಪರಿಶೀಲಿಸಲು" ಸಮಯ ಬೇಕು ಎಂದು ಬರೆದರು. ಮತ್ತು ಈಗ, ಒಂದೆರಡು ದಿನಗಳ ನಂತರ, ಇಮೇಲ್ ಬರುತ್ತದೆ, ಇದರಲ್ಲಿ ಪೈಥಾನ್ ಕಾರ್ಯವನ್ನು ಬರೆಯಲಾಗಿದೆ ಅದು ನನ್ನ ಆರಂಭಿಕ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸುತ್ತದೆ !!! ಆ ಸಮಯದಲ್ಲಿ, NiPyAPI ಆವೃತ್ತಿಯು 0.13.3 ಆಗಿತ್ತು ಮತ್ತು ಸಹಜವಾಗಿ, ಅದರಲ್ಲಿ ಅಂತಹದ್ದೇನೂ ಇರಲಿಲ್ಲ. ಆದರೆ ಇತ್ತೀಚೆಗೆ ಬಿಡುಗಡೆಯಾದ ಆವೃತ್ತಿ 0.14.0 ನಲ್ಲಿ, ಈ ಕಾರ್ಯವನ್ನು ಈಗಾಗಲೇ ಲೈಬ್ರರಿಯಲ್ಲಿ ಸೇರಿಸಲಾಗಿದೆ. ಭೇಟಿ ಮಾಡಿ

nipyapi.canvas.set_remote_process_group_transmission

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

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

ಅಷ್ಟೇ. NiFi ನಲ್ಲಿ ಹರಿವಿನ ವಿತರಣೆಯನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸಲು ನಾನು 3 ವಿಧಾನಗಳನ್ನು ವಿವರಿಸಿದ್ದೇನೆ, ಡೆವಲಪರ್ ಎದುರಿಸಬಹುದಾದ ಮೋಸಗಳು ಮತ್ತು ವಿತರಣೆಯನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸಲು ಕಾರ್ಯ ಕೋಡ್ ಅನ್ನು ಒದಗಿಸಲಾಗಿದೆ. ನೀವು ಈ ವಿಷಯದ ಬಗ್ಗೆ ನನ್ನಂತೆಯೇ ಆಸಕ್ತಿ ಹೊಂದಿದ್ದರೆ - ಬರೆಯಿರಿ!

ಮೂಲ: www.habr.com