ಎಲ್ಲರೂ ಹಲೋ!

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

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

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

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

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

ಅಪಾಚೆ ನಿಫೈ ರಿಜಿಸ್ಟ್ರಿಯು ಅಪಾಚೆ ನಿಫೈನ ಉಪಯೋಜನೆಯಾಗಿದ್ದು, ಹರಿವಿನ ಸಂಗ್ರಹಣೆ ಮತ್ತು ಆವೃತ್ತಿ ನಿಯಂತ್ರಣ ಸಾಧನವನ್ನು ಒದಗಿಸುತ್ತದೆ. ಇದು ಜಿಐಟಿಯಂತಿದೆ. ರಿಜಿಸ್ಟ್ರಿಯನ್ನು ಸ್ಥಾಪಿಸುವುದು, ಕಾನ್ಫಿಗರ್ ಮಾಡುವುದು ಮತ್ತು ಬಳಸುವ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಇಲ್ಲಿ ಕಾಣಬಹುದು ಅಧಿಕೃತ ದಸ್ತಾವೇಜನ್ನುಹರಿವನ್ನು ಸಂಗ್ರಹಣೆಗಾಗಿ ಪ್ರಕ್ರಿಯೆಯ ಗುಂಪಾಗಿ ವರ್ಗೀಕರಿಸಲಾಗಿದೆ ಮತ್ತು ಅದನ್ನು ನೋಂದಾವಣೆಯಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗಿದೆ. ನಾವು ನಂತರ ಲೇಖನದಲ್ಲಿ ಇದಕ್ಕೆ ಹಿಂತಿರುಗುತ್ತೇವೆ.

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

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

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

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

1. NiFi ಬದಲಿಗೆ MiNiFi ಬಳಸಿ
2. ನಿಫೈ ಸಿಎಲ್ಐ
3. ನಿಪ್ಯಾಪಿಐ

MiNiFi ಬಳಸುವುದು

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

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

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

1. ಮಿನಿಫೈ ನಿಫೈನಲ್ಲಿರುವ ಎಲ್ಲಾ ಪ್ರೊಸೆಸರ್‌ಗಳನ್ನು ಹೊಂದಿಲ್ಲ.
2. ಮಿನಿಫೈನಲ್ಲಿರುವ ಪ್ರೊಸೆಸರ್ ಆವೃತ್ತಿಗಳು ನಿಫೈನಲ್ಲಿರುವ ಪ್ರೊಸೆಸರ್ ಆವೃತ್ತಿಗಳಿಗಿಂತ ಹಿಂದುಳಿದಿವೆ.

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

ನಿಫೈ ಸಿಎಲ್ಐ

ಇವರಿಂದ ನಿರ್ಣಯಿಸುವುದು ವಿವರಣೆ ಈ ಉಪಕರಣವನ್ನು ಅಧಿಕೃತ ವೆಬ್‌ಸೈಟ್‌ನಲ್ಲಿ ಪಟ್ಟಿ ಮಾಡಲಾಗಿದೆ. ಇದು ಹರಿವಿನ ವಿತರಣೆ ಮತ್ತು ಪ್ರಕ್ರಿಯೆ ನಿರ್ವಹಣೆಯ ಕ್ಷೇತ್ರಗಳಲ್ಲಿ 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 ನಿದರ್ಶನವನ್ನು ನಾವು ಪ್ರಕ್ರಿಯೆ ಗುಂಪನ್ನು ನಿಯೋಜಿಸುವ ಹೋಸ್ಟ್ ಆಗಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು.

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

#> 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
}

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

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

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

ನಿಪ್ಯಾಪಿಐ

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, которое подтягиваем

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

ಬಳಸಿಕೊಂಡು nifi ನಿದರ್ಶನಕ್ಕೆ ರಿಜಿಸ್ಟ್ರಿಯನ್ನು ಸಂಪರ್ಕಿಸಲಾಗುತ್ತಿದೆ

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 ಯೋಜನೆಯು ಸಕ್ರಿಯವಾಗಿ ಅಭಿವೃದ್ಧಿ ಹೊಂದುತ್ತಿದೆ, ಮತ್ತು ನೀವು ಯಾವುದೇ ಸಮಸ್ಯೆಗಳನ್ನು ಎದುರಿಸಿದರೆ, ನೀವು ಡೆವಲಪರ್ ಅನ್ನು ಸಂಪರ್ಕಿಸಬಹುದು. ಮೂರನೆಯದಾಗಿ, ಸಂಕೀರ್ಣ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸಲು NiPyAPI NiFi ನೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸಲು ಹೆಚ್ಚು ಹೊಂದಿಕೊಳ್ಳುವ ಸಾಧನವಾಗಿದೆ. ಉದಾಹರಣೆಗೆ, ಹರಿವಿನಲ್ಲಿರುವ ಸಂದೇಶ ಸರತಿ ಸಾಲುಗಳು ಪ್ರಸ್ತುತ ಖಾಲಿಯಾಗಿವೆಯೇ ಮತ್ತು ಪ್ರಕ್ರಿಯೆ ಗುಂಪನ್ನು ನವೀಕರಿಸಬಹುದೇ ಎಂದು ನಿರ್ಧರಿಸುವುದು.

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

ಮೂಲ: www.habr.com