ਹੈਲੋ ਹਰ ਕੋਈ!

ਕੰਮ ਹੇਠ ਲਿਖੇ ਅਨੁਸਾਰ ਹੈ - ਉਪਰੋਕਤ ਤਸਵੀਰ ਵਿੱਚ ਦਿਖਾਇਆ ਗਿਆ ਇੱਕ ਪ੍ਰਵਾਹ ਹੈ, ਜਿਸ ਨੂੰ N ਸਰਵਰਾਂ ਵਿੱਚ ਰੋਲ ਆਊਟ ਕਰਨ ਦੀ ਲੋੜ ਹੈ ਅਪਾਚੇ ਨੀਫਾਈ. ਫਲੋ ਟੈਸਟ - ਇੱਕ ਫਾਈਲ ਤਿਆਰ ਕੀਤੀ ਜਾ ਰਹੀ ਹੈ ਅਤੇ ਕਿਸੇ ਹੋਰ NiFi ਉਦਾਹਰਣ ਨੂੰ ਭੇਜੀ ਜਾ ਰਹੀ ਹੈ। ਡੇਟਾ ਟ੍ਰਾਂਸਫਰ NiFi ਸਾਈਟ ਤੋਂ ਸਾਈਟ ਪ੍ਰੋਟੋਕੋਲ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਹੁੰਦਾ ਹੈ।

NiFi ਸਾਈਟ ਟੂ ਸਾਈਟ (S2S) NiFi ਉਦਾਹਰਨਾਂ ਵਿਚਕਾਰ ਡੇਟਾ ਟ੍ਰਾਂਸਫਰ ਕਰਨ ਦਾ ਇੱਕ ਸੁਰੱਖਿਅਤ, ਬਹੁਤ ਜ਼ਿਆਦਾ ਅਨੁਕੂਲਿਤ ਤਰੀਕਾ ਹੈ। ਦੇਖੋ ਕਿ S2S ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ ਦਸਤਾਵੇਜ਼ ਅਤੇ S2S ਨੂੰ ਦੇਖਣ ਦੀ ਇਜਾਜ਼ਤ ਦੇਣ ਲਈ ਆਪਣੇ NiFi ਉਦਾਹਰਨ ਨੂੰ ਸੈਟ ਅਪ ਕਰਨਾ ਯਾਦ ਰੱਖਣਾ ਮਹੱਤਵਪੂਰਨ ਹੈ ਇੱਥੇ.

ਜਦੋਂ S2S ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਡੇਟਾ ਟ੍ਰਾਂਸਫਰ ਦੀ ਗੱਲ ਆਉਂਦੀ ਹੈ, ਤਾਂ ਇੱਕ ਉਦਾਹਰਣ ਨੂੰ ਕਲਾਇੰਟ ਕਿਹਾ ਜਾਂਦਾ ਹੈ, ਦੂਜਾ ਇੱਕ ਸਰਵਰ ਹੁੰਦਾ ਹੈ। ਕਲਾਇੰਟ ਡੇਟਾ ਭੇਜਦਾ ਹੈ, ਸਰਵਰ ਇਸਨੂੰ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ. ਉਹਨਾਂ ਵਿਚਕਾਰ ਡੇਟਾ ਟ੍ਰਾਂਸਫਰ ਸੈਟ ਅਪ ਕਰਨ ਦੇ ਦੋ ਤਰੀਕੇ:

1. ਪੁਸ਼. ਰਿਮੋਟ ਪ੍ਰੋਸੈਸ ਗਰੁੱਪ (RPG) ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਕਲਾਇੰਟ ਇੰਸਟੈਂਸ ਤੋਂ ਡਾਟਾ ਭੇਜਿਆ ਜਾਂਦਾ ਹੈ। ਸਰਵਰ ਉਦਾਹਰਨ 'ਤੇ, ਇਨਪੁਟ ਪੋਰਟ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਡੇਟਾ ਪ੍ਰਾਪਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ
2. ਖਿੱਚੋ. ਸਰਵਰ ਆਰਪੀਜੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਡੇਟਾ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ, ਕਲਾਇੰਟ ਆਉਟਪੁੱਟ ਪੋਰਟ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਭੇਜਦਾ ਹੈ।

ਰੋਲਿੰਗ ਲਈ ਪ੍ਰਵਾਹ ਅਪਾਚੇ ਰਜਿਸਟਰੀ ਵਿੱਚ ਸਟੋਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

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 ਕੋਲ ਪ੍ਰਵਾਹ ਸੰਰਚਨਾ ਲਈ ਗ੍ਰਾਫਿਕਲ ਇੰਟਰਫੇਸ ਨਹੀਂ ਹੈ। MiNiFy ਦੀ ਇੱਕ ਗ੍ਰਾਫਿਕਲ ਇੰਟਰਫੇਸ ਦੀ ਘਾਟ ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਇਹ minifi ਵਿੱਚ ਪ੍ਰਵਾਹ ਡਿਲੀਵਰੀ ਦੀ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ ਜ਼ਰੂਰੀ ਹੈ। ਕਿਉਂਕਿ MiNiFy ਦੀ ਸਰਗਰਮੀ ਨਾਲ IOT ਵਿੱਚ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਇਸ ਵਿੱਚ ਬਹੁਤ ਸਾਰੇ ਭਾਗ ਹਨ ਅਤੇ ਅੰਤਮ ਮਿੰਨੀ ਉਦਾਹਰਨਾਂ ਤੱਕ ਪ੍ਰਵਾਹ ਪ੍ਰਦਾਨ ਕਰਨ ਦੀ ਪ੍ਰਕਿਰਿਆ ਸਵੈਚਲਿਤ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ। ਇੱਕ ਜਾਣਿਆ ਕੰਮ, ਠੀਕ ਹੈ?

ਇੱਕ ਹੋਰ ਸਬਪ੍ਰੋਜੈਕਟ, MiNiFi C2 ਸਰਵਰ, ਇਸ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰੇਗਾ। ਇਹ ਉਤਪਾਦ ਡਿਪਲਾਇਮੈਂਟ ਆਰਕੀਟੈਕਚਰ ਵਿੱਚ ਕੇਂਦਰੀ ਬਿੰਦੂ ਬਣਨ ਦਾ ਇਰਾਦਾ ਹੈ। ਵਾਤਾਵਰਣ ਨੂੰ ਕਿਵੇਂ ਸੰਰਚਿਤ ਕਰਨਾ ਹੈ - ਵਿੱਚ ਦੱਸਿਆ ਗਿਆ ਹੈ ਇਸ ਲੇਖ Habré 'ਤੇ ਅਤੇ ਜਾਣਕਾਰੀ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ ਕਾਫੀ ਹੈ। MiNiFi C2 ਸਰਵਰ ਦੇ ਨਾਲ ਆਪਣੇ ਆਪ ਇਸਦੀ ਸੰਰਚਨਾ ਨੂੰ ਅੱਪਡੇਟ ਕਰਦਾ ਹੈ। ਇਸ ਪਹੁੰਚ ਦੀ ਇੱਕੋ ਇੱਕ ਕਮਜ਼ੋਰੀ ਇਹ ਹੈ ਕਿ ਤੁਹਾਨੂੰ 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 ਉਦਾਹਰਣ ਨੂੰ ਹੋਸਟ ਦੇ ਤੌਰ ਤੇ ਨਿਰਧਾਰਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਜਿਸ 'ਤੇ ਅਸੀਂ ਪ੍ਰਕਿਰਿਆ ਸਮੂਹ ਨੂੰ ਰੋਲ ਕਰਦੇ ਹਾਂ।

ਰੁਕੇ ਹੋਏ ਪ੍ਰੋਸੈਸਰਾਂ ਨਾਲ ਪ੍ਰੋਸੈਸ ਗਰੁੱਪ ਜੋੜਿਆ ਗਿਆ, ਉਹਨਾਂ ਨੂੰ ਸ਼ੁਰੂ ਕਰਨ ਦੀ ਲੋੜ ਹੈ

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

ਬਹੁਤ ਵਧੀਆ, ਪ੍ਰੋਸੈਸਰ ਸ਼ੁਰੂ ਹੋ ਗਏ ਹਨ। ਹਾਲਾਂਕਿ, ਸਮੱਸਿਆ ਦੀਆਂ ਸਥਿਤੀਆਂ ਦੇ ਅਨੁਸਾਰ, ਸਾਨੂੰ ਹੋਰ ਮੌਕਿਆਂ 'ਤੇ ਡੇਟਾ ਭੇਜਣ ਲਈ NiFi ਉਦਾਹਰਨਾਂ ਦੀ ਲੋੜ ਹੈ। ਚਲੋ ਮੰਨ ਲਓ ਕਿ ਸਰਵਰ ਨੂੰ ਡੇਟਾ ਟ੍ਰਾਂਸਫਰ ਕਰਨ ਲਈ ਪੁਸ਼ ਵਿਧੀ ਦੀ ਚੋਣ ਕੀਤੀ ਗਈ ਸੀ। ਡੇਟਾ ਟ੍ਰਾਂਸਫਰ ਨੂੰ ਸੰਗਠਿਤ ਕਰਨ ਲਈ, ਸਾਡੇ ਪ੍ਰਵਾਹ ਵਿੱਚ ਪਹਿਲਾਂ ਹੀ ਸ਼ਾਮਲ ਕੀਤੇ ਗਏ ਰਿਮੋਟ ਪ੍ਰੋਸੈਸ ਗਰੁੱਪ (ਆਰਪੀਜੀ) 'ਤੇ ਡੇਟਾ ਟ੍ਰਾਂਸਫਰ (ਪ੍ਰਸਾਰਿਤ ਕਰਨ ਨੂੰ ਸਮਰੱਥ) ਨੂੰ ਸਮਰੱਥ ਕਰਨਾ ਜ਼ਰੂਰੀ ਹੈ।

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

NiPyAPI ਇੱਕ ਪਾਈਥਨ ਲਾਇਬ੍ਰੇਰੀ ਹੈ ਜੋ NiFi ਉਦਾਹਰਨਾਂ ਨਾਲ ਇੰਟਰੈਕਟ ਕਰਨ ਲਈ ਹੈ। ਦਸਤਾਵੇਜ਼ੀ ਪੰਨਾ ਲਾਇਬ੍ਰੇਰੀ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਲੋੜੀਂਦੀ ਜਾਣਕਾਰੀ ਸ਼ਾਮਲ ਹੈ। ਤੇਜ਼ ਸ਼ੁਰੂਆਤ ਵਿੱਚ ਦੱਸਿਆ ਗਿਆ ਹੈ ਪ੍ਰੋਜੈਕਟ github 'ਤੇ.

ਸੰਰਚਨਾ ਨੂੰ ਰੋਲ ਆਊਟ ਕਰਨ ਲਈ ਸਾਡੀ ਸਕ੍ਰਿਪਟ ਇੱਕ ਪਾਈਥਨ ਪ੍ਰੋਗਰਾਮ ਹੈ। ਆਓ ਕੋਡਿੰਗ ਵੱਲ ਵਧੀਏ।
ਅਗਲੇ ਕੰਮ ਲਈ ਸੰਰਚਨਾ ਸੈੱਟਅੱਪ ਕਰੋ। ਸਾਨੂੰ ਹੇਠਾਂ ਦਿੱਤੇ ਪੈਰਾਮੀਟਰਾਂ ਦੀ ਲੋੜ ਹੋਵੇਗੀ:

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

ਅਤੇ ਫਿਰ ਅਸੀਂ ਖੋਜ ਕਰ ਸਕਦੇ ਹਾਂ, ਉਦਾਹਰਨ ਲਈ, ਨਾਮ ਦੁਆਰਾ।

ਮੈਂ ਟੈਂਪਲੇਟ ਨੂੰ ਅਪਡੇਟ ਕਰਨ ਦੀ ਪ੍ਰਕਿਰਿਆ ਦਾ ਵਰਣਨ ਨਹੀਂ ਕਰਾਂਗਾ, ਮੈਂ ਸਿਰਫ ਇਹ ਕਹਾਂਗਾ ਕਿ ਜੇ ਟੈਂਪਲੇਟ ਦੇ ਨਵੇਂ ਸੰਸਕਰਣ ਵਿੱਚ ਪ੍ਰੋਸੈਸਰ ਸ਼ਾਮਲ ਕੀਤੇ ਗਏ ਹਨ, ਤਾਂ ਕਤਾਰਾਂ ਵਿੱਚ ਸੰਦੇਸ਼ਾਂ ਦੀ ਮੌਜੂਦਗੀ ਨਾਲ ਕੋਈ ਸਮੱਸਿਆ ਨਹੀਂ ਹੈ. ਪਰ ਜੇ ਪ੍ਰੋਸੈਸਰਾਂ ਨੂੰ ਹਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਸਮੱਸਿਆਵਾਂ ਪੈਦਾ ਹੋ ਸਕਦੀਆਂ ਹਨ (ਨਿਫਾਈ ਪ੍ਰੋਸੈਸਰ ਨੂੰ ਹਟਾਉਣ ਦੀ ਇਜਾਜ਼ਤ ਨਹੀਂ ਦਿੰਦਾ ਹੈ ਜੇਕਰ ਇਸਦੇ ਸਾਹਮਣੇ ਇੱਕ ਸੁਨੇਹਾ ਕਤਾਰ ਇਕੱਠੀ ਹੋ ਜਾਂਦੀ ਹੈ). ਜੇ ਤੁਸੀਂ ਇਸ ਵਿੱਚ ਦਿਲਚਸਪੀ ਰੱਖਦੇ ਹੋ ਕਿ ਮੈਂ ਇਸ ਸਮੱਸਿਆ ਨੂੰ ਕਿਵੇਂ ਹੱਲ ਕੀਤਾ - ਮੈਨੂੰ ਲਿਖੋ, ਕਿਰਪਾ ਕਰਕੇ, ਅਸੀਂ ਇਸ ਨੁਕਤੇ 'ਤੇ ਚਰਚਾ ਕਰਾਂਗੇ. ਲੇਖ ਦੇ ਅੰਤ ਵਿੱਚ ਸੰਪਰਕ. ਆਉ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਸਮੂਹ ਨੂੰ ਜੋੜਨ ਦੇ ਪੜਾਅ 'ਤੇ ਚੱਲੀਏ।

ਸਕ੍ਰਿਪਟ ਨੂੰ ਡੀਬੱਗ ਕਰਦੇ ਸਮੇਂ, ਮੈਨੂੰ ਇੱਕ ਵਿਸ਼ੇਸ਼ਤਾ ਮਿਲੀ ਕਿ ਵਹਾਅ ਦਾ ਨਵੀਨਤਮ ਸੰਸਕਰਣ ਹਮੇਸ਼ਾਂ ਖਿੱਚਿਆ ਨਹੀਂ ਜਾਂਦਾ ਹੈ, ਇਸ ਲਈ ਮੈਂ ਸਿਫ਼ਾਰਿਸ਼ ਕਰਦਾ ਹਾਂ ਕਿ ਤੁਸੀਂ ਪਹਿਲਾਂ ਇਸ ਸੰਸਕਰਣ ਨੂੰ ਸਪੱਸ਼ਟ ਕਰੋ:

nipyapi.versioning.get_latest_flow_ver

ਪ੍ਰਕਿਰਿਆ ਸਮੂਹ ਨੂੰ ਲਾਗੂ ਕਰੋ:

nipyapi.versioning.deploy_flow_version

ਸ਼ੁਰੂਆਤੀ ਪ੍ਰੋਸੈਸਰ:

nipyapi.canvas.schedule_process_group

ਸੀਐਲਆਈ ਬਾਰੇ ਬਲਾਕ ਵਿੱਚ, ਇਹ ਲਿਖਿਆ ਗਿਆ ਸੀ ਕਿ ਰਿਮੋਟ ਪ੍ਰਕਿਰਿਆ ਸਮੂਹ ਵਿੱਚ ਡੇਟਾ ਟ੍ਰਾਂਸਫਰ ਆਟੋਮੈਟਿਕਲੀ ਯੋਗ ਨਹੀਂ ਹੈ? ਸਕ੍ਰਿਪਟ ਨੂੰ ਲਾਗੂ ਕਰਦੇ ਸਮੇਂ, ਮੈਨੂੰ ਵੀ ਇਸ ਸਮੱਸਿਆ ਦਾ ਸਾਹਮਣਾ ਕਰਨਾ ਪਿਆ। ਉਸ ਸਮੇਂ, ਮੈਂ API ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਡੇਟਾ ਟ੍ਰਾਂਸਫਰ ਸ਼ੁਰੂ ਨਹੀਂ ਕਰ ਸਕਿਆ ਅਤੇ ਮੈਂ NiPyAPI ਲਾਇਬ੍ਰੇਰੀ ਦੇ ਡਿਵੈਲਪਰ ਨੂੰ ਲਿਖਣ ਅਤੇ ਸਲਾਹ / ਮਦਦ ਮੰਗਣ ਦਾ ਫੈਸਲਾ ਕੀਤਾ। ਡਿਵੈਲਪਰ ਨੇ ਮੈਨੂੰ ਜਵਾਬ ਦਿੱਤਾ, ਅਸੀਂ ਸਮੱਸਿਆ 'ਤੇ ਚਰਚਾ ਕੀਤੀ ਅਤੇ ਉਸਨੇ ਲਿਖਿਆ ਕਿ ਉਸਨੂੰ "ਕੁਝ ਚੈੱਕ" ਕਰਨ ਲਈ ਸਮਾਂ ਚਾਹੀਦਾ ਹੈ। ਅਤੇ ਹੁਣ, ਕੁਝ ਦਿਨਾਂ ਬਾਅਦ, ਇੱਕ ਈਮੇਲ ਆਉਂਦੀ ਹੈ ਜਿਸ ਵਿੱਚ ਇੱਕ ਪਾਈਥਨ ਫੰਕਸ਼ਨ ਲਿਖਿਆ ਹੋਇਆ ਹੈ ਜੋ ਮੇਰੀ ਸ਼ੁਰੂਆਤੀ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਦਾ ਹੈ !!! ਉਸ ਸਮੇਂ, NiPyAPI ਸੰਸਕਰਣ 0.13.3 ਸੀ ਅਤੇ, ਬੇਸ਼ਕ, ਇਸ ਵਿੱਚ ਕੁਝ ਵੀ ਨਹੀਂ ਸੀ। ਪਰ ਵਰਜਨ 0.14.0 ਵਿੱਚ, ਜੋ ਕਿ ਹਾਲ ਹੀ ਵਿੱਚ ਜਾਰੀ ਕੀਤਾ ਗਿਆ ਸੀ, ਇਹ ਫੰਕਸ਼ਨ ਪਹਿਲਾਂ ਹੀ ਲਾਇਬ੍ਰੇਰੀ ਵਿੱਚ ਸ਼ਾਮਲ ਕੀਤਾ ਗਿਆ ਹੈ. ਮਿਲੋ

nipyapi.canvas.set_remote_process_group_transmission

ਇਸ ਲਈ, NiPyAPI ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਮਦਦ ਨਾਲ, ਅਸੀਂ ਰਜਿਸਟਰੀ ਨੂੰ ਕਨੈਕਟ ਕੀਤਾ, ਪ੍ਰਵਾਹ ਨੂੰ ਰੋਲ ਅੱਪ ਕੀਤਾ, ਅਤੇ ਪ੍ਰੋਸੈਸਰ ਅਤੇ ਡਾਟਾ ਟ੍ਰਾਂਸਫਰ ਵੀ ਸ਼ੁਰੂ ਕੀਤਾ। ਫਿਰ ਤੁਸੀਂ ਕੋਡ ਨੂੰ ਕੰਘੀ ਕਰ ਸਕਦੇ ਹੋ, ਹਰ ਕਿਸਮ ਦੇ ਚੈਕ ਜੋੜ ਸਕਦੇ ਹੋ, ਲੌਗਿੰਗ ਕਰ ਸਕਦੇ ਹੋ, ਅਤੇ ਬੱਸ ਹੋ ਗਿਆ। ਪਰ ਇਹ ਬਿਲਕੁਲ ਵੱਖਰੀ ਕਹਾਣੀ ਹੈ।

ਆਟੋਮੇਸ਼ਨ ਵਿਕਲਪਾਂ ਵਿੱਚੋਂ ਜਿਨ੍ਹਾਂ 'ਤੇ ਮੈਂ ਵਿਚਾਰ ਕੀਤਾ, ਬਾਅਦ ਵਾਲੇ ਮੈਨੂੰ ਸਭ ਤੋਂ ਕੁਸ਼ਲ ਜਾਪਦੇ ਸਨ। ਪਹਿਲਾਂ, ਇਹ ਅਜੇ ਵੀ ਪਾਈਥਨ ਕੋਡ ਹੈ, ਜਿਸ ਵਿੱਚ ਤੁਸੀਂ ਸਹਾਇਕ ਪ੍ਰੋਗਰਾਮ ਕੋਡ ਨੂੰ ਏਮਬੇਡ ਕਰ ਸਕਦੇ ਹੋ ਅਤੇ ਇੱਕ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਦੇ ਸਾਰੇ ਲਾਭਾਂ ਦਾ ਅਨੰਦ ਲੈ ਸਕਦੇ ਹੋ। ਦੂਜਾ, NiPyAPI ਪ੍ਰੋਜੈਕਟ ਸਰਗਰਮੀ ਨਾਲ ਵਿਕਾਸ ਕਰ ਰਿਹਾ ਹੈ ਅਤੇ ਸਮੱਸਿਆਵਾਂ ਦੀ ਸਥਿਤੀ ਵਿੱਚ ਤੁਸੀਂ ਡਿਵੈਲਪਰ ਨੂੰ ਲਿਖ ਸਕਦੇ ਹੋ। ਤੀਜਾ, NiPyAPI ਅਜੇ ਵੀ ਗੁੰਝਲਦਾਰ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਹੱਲ ਕਰਨ ਵਿੱਚ NiFi ਨਾਲ ਗੱਲਬਾਤ ਕਰਨ ਲਈ ਇੱਕ ਵਧੇਰੇ ਲਚਕਦਾਰ ਸਾਧਨ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਇਹ ਨਿਰਧਾਰਤ ਕਰਨ ਵਿੱਚ ਕਿ ਕੀ ਸੰਦੇਸ਼ ਕਤਾਰਾਂ ਵਰਤਮਾਨ ਵਿੱਚ ਪ੍ਰਵਾਹ ਵਿੱਚ ਖਾਲੀ ਹਨ ਅਤੇ ਕੀ ਪ੍ਰਕਿਰਿਆ ਸਮੂਹ ਨੂੰ ਅਪਡੇਟ ਕਰਨਾ ਸੰਭਵ ਹੈ।

ਇਹ ਸਭ ਹੈ. ਮੈਂ NiFi ਵਿੱਚ ਆਟੋਮੈਟਿਕ ਵਹਾਅ ਡਿਲੀਵਰੀ ਲਈ 3 ਪਹੁੰਚਾਂ ਦਾ ਵਰਣਨ ਕੀਤਾ ਹੈ, ਇੱਕ ਡਿਵੈਲਪਰ ਨੂੰ ਆਟੋਮੈਟਿਕ ਡਿਲੀਵਰੀ ਲਈ ਇੱਕ ਕਾਰਜ ਕੋਡ ਪ੍ਰਦਾਨ ਕੀਤਾ ਗਿਆ ਹੈ। ਜੇ ਤੁਸੀਂ ਇਸ ਵਿਸ਼ੇ ਵਿੱਚ ਉਨੇ ਹੀ ਦਿਲਚਸਪੀ ਰੱਖਦੇ ਹੋ ਜਿਵੇਂ ਕਿ ਮੈਂ ਹਾਂ - ਲਿਖੋ!

ਸਰੋਤ: www.habr.com