ഹലോ എല്ലാവർക്കും!

ചുമതല ഇപ്രകാരമാണ് - മുകളിലെ ചിത്രത്തിൽ കാണിച്ചിരിക്കുന്ന ഒരു ഫ്ലോ ഉണ്ട്, അത് N സെർവറുകളിലേക്ക് റോൾ ചെയ്യേണ്ടതുണ്ട് അപ്പാച്ചെ നിഫൈ. ഫ്ലോ ടെസ്റ്റ് - ഒരു ഫയൽ ജനറേറ്റ് ചെയ്യുകയും മറ്റൊരു NiFi ഉദാഹരണത്തിലേക്ക് അയയ്ക്കുകയും ചെയ്യുന്നു. NiFi സൈറ്റ് ടു സൈറ്റ് പ്രോട്ടോക്കോൾ ഉപയോഗിച്ചാണ് ഡാറ്റ കൈമാറ്റം നടക്കുന്നത്.

NiFi ഇൻസ്‌റ്റൻസുകൾക്കിടയിൽ ഡാറ്റ കൈമാറ്റം ചെയ്യുന്നതിനുള്ള സുരക്ഷിതവും ഉയർന്ന ഇഷ്‌ടാനുസൃതമാക്കാവുന്നതുമായ മാർഗമാണ് NiFi സൈറ്റ് ടു സൈറ്റ് (S2S). S2S എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് കാണുക പ്രമാണീകരണം കൂടാതെ S2S കാണാൻ അനുവദിക്കുന്നതിന് നിങ്ങളുടെ NiFi ഇൻസ്റ്റൻസ് സജ്ജീകരിക്കുന്നത് ഓർത്തിരിക്കേണ്ടത് പ്രധാനമാണ് ഇവിടെ.

S2S ഉപയോഗിച്ചുള്ള ഡാറ്റാ കൈമാറ്റത്തിന്റെ കാര്യത്തിൽ, ഒരു ഉദാഹരണത്തെ ക്ലയന്റ് എന്ന് വിളിക്കുന്നു, രണ്ടാമത്തേത് ഒരു സെർവറാണ്. ക്ലയന്റ് ഡാറ്റ അയയ്ക്കുന്നു, സെർവർ അത് സ്വീകരിക്കുന്നു. അവയ്ക്കിടയിൽ ഡാറ്റ കൈമാറ്റം സജ്ജീകരിക്കുന്നതിനുള്ള രണ്ട് വഴികൾ:

1. ഉന്ത്. ഒരു റിമോട്ട് പ്രോസസ് ഗ്രൂപ്പ് (RPG) ഉപയോഗിച്ച് ക്ലയന്റ് സംഭവത്തിൽ നിന്ന് ഡാറ്റ അയയ്ക്കുന്നു. സെർവർ ഉദാഹരണത്തിൽ, ഇൻപുട്ട് പോർട്ട് ഉപയോഗിച്ച് ഡാറ്റ സ്വീകരിക്കുന്നു
2. വലിക്കുക. സെർവർ RPG ഉപയോഗിച്ച് ഡാറ്റ സ്വീകരിക്കുന്നു, ക്ലയന്റ് ഔട്ട്പുട്ട് പോർട്ട് ഉപയോഗിച്ച് അയയ്ക്കുന്നു.

റോളിങ്ങിനുള്ള ഫ്ലോ അപ്പാച്ചെ രജിസ്ട്രിയിൽ സംഭരിച്ചിരിക്കുന്നു.

ഫ്ലോ സ്റ്റോറേജും വേർഷനിംഗ് ടൂളും നൽകുന്ന അപ്പാച്ചെ നിഫൈയുടെ ഒരു ഉപപദ്ധതിയാണ് അപ്പാച്ചെ നിഫൈ രജിസ്ട്രി. ഒരുതരം GIT. രജിസ്ട്രി ഇൻസ്റ്റാൾ ചെയ്യുന്നതും കോൺഫിഗർ ചെയ്യുന്നതും ജോലി ചെയ്യുന്നതും സംബന്ധിച്ച വിവരങ്ങൾ ഇതിൽ കാണാം ഔദ്യോഗിക ഡോക്യുമെന്റേഷൻ. സംഭരണത്തിനായുള്ള ഫ്ലോ ഒരു പ്രോസസ്സ് ഗ്രൂപ്പിലേക്ക് സംയോജിപ്പിച്ച് ഈ ഫോമിൽ രജിസ്ട്രിയിൽ സംഭരിക്കുന്നു. ലേഖനത്തിൽ ഞങ്ങൾ പിന്നീട് ഇതിലേക്ക് മടങ്ങും.

തുടക്കത്തിൽ, N ഒരു ചെറിയ സംഖ്യ ആയിരിക്കുമ്പോൾ, ഒഴുക്ക് ന്യായമായ സമയത്ത് കൈകൊണ്ട് കൈമാറുകയും അപ്ഡേറ്റ് ചെയ്യുകയും ചെയ്യുന്നു.

എന്നാൽ N വളരുന്നതിനനുസരിച്ച്, കൂടുതൽ പ്രശ്നങ്ങളുണ്ട്:

1. ഫ്ലോ അപ്ഡേറ്റ് ചെയ്യാൻ കൂടുതൽ സമയമെടുക്കും. നിങ്ങൾ എല്ലാ സെർവറുകളിലേക്കും പോകേണ്ടതുണ്ട്
2. ടെംപ്ലേറ്റുകൾ അപ്ഡേറ്റ് ചെയ്യുന്നതിൽ പിശകുകൾ ഉണ്ട്. ഇവിടെ അവർ അപ്ഡേറ്റ് ചെയ്തു, പക്ഷേ ഇവിടെ അവർ മറന്നു
3. സമാനമായ നിരവധി പ്രവർത്തനങ്ങൾ നടത്തുമ്പോൾ മനുഷ്യ പിശക്

പ്രക്രിയ ഓട്ടോമേറ്റ് ചെയ്യേണ്ടത് അത്യാവശ്യമാണെന്ന വസ്തുതയിലേക്ക് ഇതെല്ലാം നമ്മെ എത്തിക്കുന്നു. ഈ പ്രശ്നം പരിഹരിക്കാൻ ഞാൻ ഇനിപ്പറയുന്ന വഴികൾ പരീക്ഷിച്ചു:

1. NiFi-ക്ക് പകരം MiNiFi ഉപയോഗിക്കുക
2. നിഫൈ CLI
3. NiPyAPI

MiNiFi ഉപയോഗിക്കുന്നു

ApacheMiNify അപ്പാച്ചെ നിഫൈയുടെ ഒരു ഉപപദ്ധതിയാണ്. NiFi-യുടെ അതേ പ്രോസസ്സറുകൾ ഉപയോഗിക്കുന്ന ഒരു കോം‌പാക്റ്റ് ഏജന്റാണ് MiNiFy, NiFi-യിലെ അതേ ഫ്ലോ സൃഷ്ടിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു. ഫ്ലോ കോൺഫിഗറേഷനായി MiNiFy- ന് ഒരു ഗ്രാഫിക്കൽ ഇന്റർഫേസ് ഇല്ല എന്ന വസ്തുത കാരണം, മറ്റ് കാര്യങ്ങളിൽ, ഏജന്റിന്റെ ലാളിത്യം കൈവരിക്കാനാകും. MiNiFy യുടെ ഗ്രാഫിക്കൽ ഇന്റർഫേസിന്റെ അഭാവം അർത്ഥമാക്കുന്നത് minifi-യിലെ ഫ്ലോ ഡെലിവറി പ്രശ്നം പരിഹരിക്കേണ്ടത് ആവശ്യമാണ് എന്നാണ്. IOT-ൽ MiNiFy സജീവമായി ഉപയോഗിക്കുന്നതിനാൽ, നിരവധി ഘടകങ്ങളുണ്ട്, അവസാന മിനിഫൈ സംഭവങ്ങളിലേക്ക് ഒഴുക്ക് നൽകുന്ന പ്രക്രിയ ഓട്ടോമേറ്റഡ് ആയിരിക്കണം. പരിചിതമായ ഒരു ജോലി, അല്ലേ?

മറ്റൊരു ഉപപദ്ധതി, MiNiFi C2 സെർവർ, ഈ പ്രശ്നം പരിഹരിക്കാൻ സഹായിക്കും. ഈ ഉൽപ്പന്നം വിന്യാസ വാസ്തുവിദ്യയിലെ കേന്ദ്ര ബിന്ദുവായി ഉദ്ദേശിച്ചുള്ളതാണ്. പരിസ്ഥിതി എങ്ങനെ ക്രമീകരിക്കാം - വിവരിച്ചിരിക്കുന്നു ഈ ലേഖനം ഹബ്രെയിൽ, പ്രശ്നം പരിഹരിക്കാൻ വിവരങ്ങൾ മതിയാകും. C2 സെർവറുമായി ചേർന്ന് MiNiFi അതിന്റെ കോൺഫിഗറേഷൻ യാന്ത്രികമായി അപ്ഡേറ്റ് ചെയ്യുന്നു. ഈ സമീപനത്തിന്റെ ഒരേയൊരു പോരായ്മ നിങ്ങൾ C2 സെർവറിൽ ടെംപ്ലേറ്റുകൾ സൃഷ്ടിക്കേണ്ടതുണ്ട് എന്നതാണ്, രജിസ്ട്രിയിൽ ഒരു ലളിതമായ പ്രതിബദ്ധത പോരാ.

മുകളിലുള്ള ലേഖനത്തിൽ വിവരിച്ച ഓപ്ഷൻ പ്രവർത്തിക്കുന്നു, അത് നടപ്പിലാക്കാൻ പ്രയാസമില്ല, എന്നാൽ ഇനിപ്പറയുന്നവ ഞങ്ങൾ മറക്കരുത്:

1. minifi ന് nifi-യിൽ നിന്നുള്ള എല്ലാ പ്രൊസസ്സറുകളും ഇല്ല
2. മിനിഫിയിലെ സിപിയു പതിപ്പുകൾ നിഫൈയിലെ സിപിയു പതിപ്പുകളേക്കാൾ പിന്നിലാണ്.

എഴുതുമ്പോൾ, നിഫൈയുടെ ഏറ്റവും പുതിയ പതിപ്പ് 1.9.2 ആണ്. ഏറ്റവും പുതിയ MiNiFi പതിപ്പിന്റെ പ്രോസസ്സർ പതിപ്പ് 1.7.0 ആണ്. MiNiFi-യിൽ പ്രോസസ്സറുകൾ ചേർക്കാൻ കഴിയും, എന്നാൽ NiFi, MiNiFi പ്രോസസറുകൾ തമ്മിലുള്ള പതിപ്പ് പൊരുത്തക്കേടുകൾ കാരണം ഇത് പ്രവർത്തിച്ചേക്കില്ല.

നിഫൈ 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 സന്ദർഭങ്ങൾ ആവശ്യമാണ്. സെർവറിലേക്ക് ഡാറ്റ കൈമാറാൻ പുഷ് രീതി തിരഞ്ഞെടുത്തുവെന്ന് നമുക്ക് അനുമാനിക്കാം. ഡാറ്റാ കൈമാറ്റം ഓർഗനൈസുചെയ്യുന്നതിന്, ഞങ്ങളുടെ ഫ്ലോയിൽ ഇതിനകം ഉൾപ്പെടുത്തിയിരിക്കുന്ന റിമോട്ട് പ്രോസസ് ഗ്രൂപ്പിൽ (ആർ‌പി‌ജി) ഡാറ്റ കൈമാറ്റം (പ്രക്ഷേപണം പ്രാപ്‌തമാക്കുക) പ്രവർത്തനക്ഷമമാക്കേണ്ടത് ആവശ്യമാണ്.

CLI-യിലെയും മറ്റ് ഉറവിടങ്ങളിലെയും ഡോക്യുമെന്റേഷനിൽ, ഡാറ്റ കൈമാറ്റം പ്രവർത്തനക്ഷമമാക്കുന്നതിനുള്ള ഒരു മാർഗ്ഗം ഞാൻ കണ്ടെത്തിയില്ല. ഇത് എങ്ങനെ ചെയ്യണമെന്ന് നിങ്ങൾക്കറിയാമെങ്കിൽ, അഭിപ്രായങ്ങളിൽ എഴുതുക.

ഞങ്ങൾക്ക് ബാഷ് ഉള്ളതിനാൽ അവസാനം വരെ പോകാൻ ഞങ്ങൾ തയ്യാറാണ്, ഞങ്ങൾ ഒരു വഴി കണ്ടെത്തും! ഈ പ്രശ്നം പരിഹരിക്കാൻ നിങ്ങൾക്ക് NiFi API ഉപയോഗിക്കാം. നമുക്ക് ഇനിപ്പറയുന്ന രീതി ഉപയോഗിക്കാം, മുകളിലുള്ള ഉദാഹരണങ്ങളിൽ നിന്ന് ഞങ്ങൾ ഐഡി എടുക്കുന്നു (ഞങ്ങളുടെ കാര്യത്തിൽ ഇത് 7f522a13-016e-1000-e504-d5b15587f2f3 ആണ്). NiFi API രീതികളുടെ വിവരണം ഇവിടെ.

ശരീരത്തിൽ, നിങ്ങൾ ഇനിപ്പറയുന്ന ഫോമിന്റെ JSON പാസാക്കേണ്ടതുണ്ട്:

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

"പ്രവർത്തിക്കുന്നതിന്" പൂരിപ്പിക്കേണ്ട പാരാമീറ്ററുകൾ:
സംസ്ഥാനം - ഡാറ്റ കൈമാറ്റ നില. ഡാറ്റ കൈമാറ്റം പ്രവർത്തനക്ഷമമാക്കാൻ ട്രാൻസ്മിറ്റിംഗ് ലഭ്യമാണ്, പ്രവർത്തനരഹിതമാക്കാൻ നിർത്തി
പതിപ്പ് - പ്രോസസർ പതിപ്പ്

സൃഷ്‌ടിക്കുമ്പോൾ പതിപ്പ് സ്ഥിരസ്ഥിതിയായി 0 ആയി മാറും, എന്നാൽ ഈ പാരാമീറ്ററുകൾ രീതി ഉപയോഗിച്ച് ലഭിക്കും

ബാഷ് സ്ക്രിപ്റ്റുകൾ ഇഷ്ടപ്പെടുന്നവർക്ക്, ഈ രീതി അനുയോജ്യമാണെന്ന് തോന്നിയേക്കാം, പക്ഷേ ഇത് എനിക്ക് ബുദ്ധിമുട്ടാണ് - ബാഷ് സ്ക്രിപ്റ്റുകൾ എന്റെ പ്രിയപ്പെട്ടതല്ല. അടുത്ത വഴി എന്റെ അഭിപ്രായത്തിൽ കൂടുതൽ രസകരവും കൂടുതൽ സൗകര്യപ്രദവുമാണ്.

NiPyAPI

NiFi സംഭവങ്ങളുമായി സംവദിക്കുന്നതിനുള്ള ഒരു പൈത്തൺ ലൈബ്രറിയാണ് NiPyAPI. ഡോക്യുമെന്റേഷൻ പേജ് ലൈബ്രറിയിൽ പ്രവർത്തിക്കാൻ ആവശ്യമായ വിവരങ്ങൾ അടങ്ങിയിരിക്കുന്നു. ദ്രുത ആരംഭത്തിൽ വിവരിച്ചിരിക്കുന്നു പദ്ധതി ഗിത്തബിൽ.

കോൺഫിഗറേഷൻ പുറത്തിറക്കുന്നതിനുള്ള ഞങ്ങളുടെ സ്ക്രിപ്റ്റ് ഒരു പൈത്തൺ പ്രോഗ്രാമാണ്. നമുക്ക് കോഡിംഗിലേക്ക് പോകാം.
തുടർന്നുള്ള ജോലികൾക്കായി കോൺഫിഗറുകൾ സജ്ജമാക്കുക. ഞങ്ങൾക്ക് ഇനിപ്പറയുന്ന പാരാമീറ്ററുകൾ ആവശ്യമാണ്:

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

തുടർന്ന് നമുക്ക് തിരയാം, ഉദാഹരണത്തിന്, പേര്.

ടെംപ്ലേറ്റ് അപ്‌ഡേറ്റ് ചെയ്യുന്ന പ്രക്രിയ ഞാൻ വിവരിക്കില്ല, ടെംപ്ലേറ്റിന്റെ പുതിയ പതിപ്പിൽ പ്രോസസ്സറുകൾ ചേർത്തിട്ടുണ്ടെങ്കിൽ, ക്യൂവിൽ സന്ദേശങ്ങളുടെ സാന്നിധ്യത്തിൽ പ്രശ്‌നങ്ങളൊന്നുമില്ലെന്ന് മാത്രമേ ഞാൻ പറയൂ. എന്നാൽ പ്രോസസ്സറുകൾ നീക്കം ചെയ്താൽ, പ്രശ്നങ്ങൾ ഉണ്ടാകാം (നിഫി പ്രൊസസറിന് മുന്നിൽ ഒരു സന്ദേശ ക്യൂ അടിഞ്ഞുകൂടിയിട്ടുണ്ടെങ്കിൽ അത് നീക്കംചെയ്യാൻ അനുവദിക്കുന്നില്ല). ഞാൻ ഈ പ്രശ്നം എങ്ങനെ പരിഹരിച്ചുവെന്ന് നിങ്ങൾക്ക് താൽപ്പര്യമുണ്ടെങ്കിൽ - എനിക്ക് എഴുതുക, ദയവായി, ഞങ്ങൾ ഈ വിഷയം ചർച്ച ചെയ്യും. ലേഖനത്തിന്റെ അവസാനം കോൺടാക്റ്റുകൾ. ഒരു പ്രോസസ് ഗ്രൂപ്പ് ചേർക്കുന്ന ഘട്ടത്തിലേക്ക് നമുക്ക് പോകാം.

സ്‌ക്രിപ്റ്റ് ഡീബഗ്ഗ് ചെയ്യുമ്പോൾ, ഫ്ലോയുടെ ഏറ്റവും പുതിയ പതിപ്പ് എല്ലായ്‌പ്പോഴും അപ്‌ലോഡ് ചെയ്യപ്പെടാത്ത ഒരു സവിശേഷത ഞാൻ കണ്ടു, അതിനാൽ നിങ്ങൾ ആദ്യം ഈ പതിപ്പ് വ്യക്തമാക്കാൻ ഞാൻ ശുപാർശ ചെയ്യുന്നു:

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