അപ്പാച്ചെ NIFI - പ്രാക്ടീസിലുള്ള ഫീച്ചറുകളുടെ ഒരു സംക്ഷിപ്ത അവലോകനം

ആമുഖം

എന്റെ നിലവിലെ ജോലിസ്ഥലത്ത് ഈ സാങ്കേതികവിദ്യയെക്കുറിച്ച് എനിക്ക് പരിചയപ്പെടേണ്ടിവന്നു. ഞാൻ ഒരു ചെറിയ പശ്ചാത്തലത്തിൽ തുടങ്ങും. അടുത്ത മീറ്റിംഗിൽ, ഞങ്ങളുമായി സംയോജനം ഉണ്ടാക്കേണ്ടതുണ്ടെന്ന് ഞങ്ങളുടെ ടീമിനോട് പറഞ്ഞു അറിയപ്പെടുന്ന സിസ്റ്റം. സംയോജനം എന്നതുകൊണ്ട് ഉദ്ദേശിക്കുന്നത്, ഈ അറിയപ്പെടുന്ന സിസ്റ്റം ഞങ്ങൾക്ക് HTTP വഴി അഭ്യർത്ഥനകൾ ഒരു നിർദ്ദിഷ്‌ട എൻഡ്‌പോയിന്റിലേക്ക് അയയ്‌ക്കും, വിചിത്രമെന്നു പറയട്ടെ, ഞങ്ങൾ ഒരു SOAP സന്ദേശത്തിന്റെ രൂപത്തിൽ പ്രതികരണങ്ങൾ തിരികെ അയയ്‌ക്കും. എല്ലാം ലളിതവും നിസ്സാരവുമാണെന്ന് തോന്നുന്നു. ഇതിൽ നിന്ന് നിങ്ങൾക്ക് ആവശ്യമുള്ളത് പിന്തുടരുന്നു ...

ലക്ഷ്യം

3 സേവനങ്ങൾ സൃഷ്ടിക്കുക. അവയിൽ ആദ്യത്തേത് ഡാറ്റാബേസ് അപ്ഡേറ്റ് സേവനമാണ്. ഈ സേവനം, ഒരു മൂന്നാം കക്ഷി സിസ്റ്റത്തിൽ നിന്ന് പുതിയ ഡാറ്റ വരുമ്പോൾ, ഡാറ്റാബേസിലെ ഡാറ്റ അപ്‌ഡേറ്റ് ചെയ്യുകയും അടുത്ത സിസ്റ്റത്തിലേക്ക് കൈമാറുന്നതിനായി CSV ഫോർമാറ്റിൽ ഒരു ഫയൽ സൃഷ്ടിക്കുകയും ചെയ്യുന്നു. രണ്ടാമത്തെ സേവനത്തിന്റെ അവസാന പോയിന്റിനെ വിളിക്കുന്നു - FTP ട്രാൻസ്പോർട്ട് സർവീസ്, അത് ട്രാൻസ്ഫർ ചെയ്ത ഫയൽ സ്വീകരിക്കുന്നു, അത് സാധൂകരിക്കുകയും FTP വഴി ഫയൽ സ്റ്റോറേജിൽ ഇടുകയും ചെയ്യുന്നു. മൂന്നാമത്തെ സേവനം, ഉപഭോക്തൃ ഡാറ്റാ ട്രാൻസ്ഫർ സേവനം, ആദ്യത്തെ രണ്ടെണ്ണവുമായി അസമന്വിതമായി പ്രവർത്തിക്കുന്നു. മുകളിൽ ചർച്ച ചെയ്ത ഫയൽ സ്വീകരിക്കുന്നതിന് ഒരു മൂന്നാം കക്ഷി ബാഹ്യ സിസ്റ്റത്തിൽ നിന്ന് ഇതിന് ഒരു അഭ്യർത്ഥന ലഭിക്കുന്നു, തയ്യാറായ പ്രതികരണ ഫയൽ എടുത്ത്, അത് പരിഷ്ക്കരിച്ച് (ഐഡി, വിവരണം, linkToFile ഫീൽഡുകൾ അപ്ഡേറ്റ് ചെയ്യുന്നു) കൂടാതെ ഒരു SOAP സന്ദേശത്തിന്റെ രൂപത്തിൽ പ്രതികരണം അയയ്ക്കുന്നു. അതായത്, മൊത്തത്തിലുള്ള ചിത്രം ഇപ്രകാരമാണ്: അപ്‌ഡേറ്റ് ചെയ്യുന്നതിനുള്ള ഡാറ്റ വരുമ്പോൾ മാത്രമേ ആദ്യത്തെ രണ്ട് സേവനങ്ങൾ അവരുടെ ജോലി ആരംഭിക്കൂ. മൂന്നാമത്തെ സേവനം നിരന്തരം പ്രവർത്തിക്കുന്നു, കാരണം വിവരങ്ങളുടെ നിരവധി ഉപഭോക്താക്കൾ ഉണ്ട്, മിനിറ്റിൽ ഏകദേശം 1000 ഡാറ്റ അഭ്യർത്ഥനകൾ. സേവനങ്ങൾ നിരന്തരം ലഭ്യമാണ് കൂടാതെ അവയുടെ സംഭവങ്ങൾ ടെസ്റ്റ്, ഡെമോ, പ്രീ-പ്രൊഡക്ഷൻ, പ്രൊഡക്ഷൻ എന്നിങ്ങനെ വ്യത്യസ്ത പരിതസ്ഥിതികളിൽ സ്ഥിതി ചെയ്യുന്നു. ഈ സേവനങ്ങൾ എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്നതിന്റെ ഒരു ഡയഗ്രം ചുവടെയുണ്ട്. അനാവശ്യ സങ്കീർണ്ണത ഒഴിവാക്കാൻ ചില വിശദാംശങ്ങൾ ലളിതമാക്കിയിട്ടുണ്ടെന്ന് ഞാൻ ഉടൻ തന്നെ വ്യക്തമാക്കട്ടെ.

സാങ്കേതിക ഡീപ്പനിംഗ്

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

എന്താണ് അത്?

ഡാറ്റയുടെ വേഗത്തിലുള്ള സമാന്തര ലോഡിംഗിനും പ്രോസസ്സിംഗിനും, ഉറവിടങ്ങൾക്കും പരിവർത്തനങ്ങൾക്കുമായി ധാരാളം പ്ലഗിനുകൾ, കോൺഫിഗറേഷനുകളുടെ പതിപ്പ് എന്നിവയ്ക്കും അതിലേറെ കാര്യങ്ങൾക്കുമുള്ള ഒരു ഡിസ്ട്രിബ്യൂഡ് ആർക്കിടെക്ചറാണ് NIFI. ഒരു നല്ല ബോണസ് അത് ഉപയോഗിക്കാൻ വളരെ എളുപ്പമാണ് എന്നതാണ്. getFile, sendHttpRequest എന്നിവയും മറ്റുള്ളവയും പോലുള്ള നിസ്സാരമായ പ്രക്രിയകളെ ചതുരങ്ങളായി പ്രതിനിധീകരിക്കാം. ഓരോ ചതുരവും ഒരു പ്രക്രിയയെ പ്രതിനിധീകരിക്കുന്നു, അതിന്റെ ഇടപെടൽ ചുവടെയുള്ള ചിത്രത്തിൽ കാണാം. പ്രോസസ്സ് സെറ്റപ്പ് ഇടപെടലുകളെക്കുറിച്ചുള്ള കൂടുതൽ വിശദമായ ഡോക്യുമെന്റേഷൻ എഴുതിയിട്ടുണ്ട് ഇവിടെ , റഷ്യൻ സംസാരിക്കുന്നവർക്ക് - ഇവിടെ. NIFI അൺപാക്ക് ചെയ്യുകയും പ്രവർത്തിപ്പിക്കുകയും ചെയ്യുന്നതെങ്ങനെ, അതുപോലെ ചതുരങ്ങൾ എന്നറിയപ്പെടുന്ന പ്രക്രിയകൾ എങ്ങനെ സൃഷ്ടിക്കാമെന്നും ഡോക്യുമെന്റേഷൻ കൃത്യമായി വിവരിക്കുന്നു.
ഒരു ലേഖനം എഴുതാനുള്ള ആശയം ജനിച്ചത് ഒരു നീണ്ട തിരച്ചിലിനും ലഭിച്ച വിവരങ്ങൾ ബോധപൂർവമായ ഒന്നായി രൂപപ്പെടുത്തുന്നതിനും ഒപ്പം ഭാവിയിലെ ഡെവലപ്പർമാർക്ക് ജീവിതം അൽപ്പം എളുപ്പമാക്കാനുള്ള ആഗ്രഹത്തിനും ശേഷമാണ്.

ഉദാഹരണം:

ചതുരങ്ങൾ എങ്ങനെ പരസ്പരം ഇടപഴകുന്നു എന്നതിന്റെ ഒരു ഉദാഹരണം പരിഗണിക്കപ്പെടുന്നു. പൊതുവായ സ്കീം വളരെ ലളിതമാണ്: ഞങ്ങൾക്ക് ഒരു HTTP അഭ്യർത്ഥന ലഭിക്കുന്നു (സിദ്ധാന്തത്തിൽ, അഭ്യർത്ഥനയുടെ ബോഡിയിൽ ഒരു ഫയലിനൊപ്പം. NIFI യുടെ കഴിവുകൾ തെളിയിക്കാൻ, ഈ ഉദാഹരണത്തിൽ, പ്രാദേശിക ഫയൽ സംഭരണത്തിൽ നിന്ന് ഒരു ഫയൽ സ്വീകരിക്കുന്നതിനുള്ള പ്രക്രിയ അഭ്യർത്ഥന ആരംഭിക്കുന്നു. ), തുടർന്ന് FH-ൽ നിന്ന് ഒരു ഫയൽ സ്വീകരിക്കുന്ന പ്രക്രിയയ്ക്ക് സമാന്തരമായി, FTP വഴി FH-ലേക്ക് നീക്കുന്ന പ്രക്രിയയ്ക്ക് സമാന്തരമായി, അഭ്യർത്ഥന ലഭിച്ചതായി ഞങ്ങൾ ഒരു പ്രതികരണം തിരികെ അയയ്ക്കുന്നു. ഫ്ലോഫയൽ എന്ന് വിളിക്കപ്പെടുന്ന പ്രക്രിയകൾ പരസ്പരം സംവദിക്കുന്നുവെന്ന് വ്യക്തമാക്കുന്നത് മൂല്യവത്താണ്. NIFI-യിലെ ആട്രിബ്യൂട്ടുകളും ഉള്ളടക്കവും സംഭരിക്കുന്ന അടിസ്ഥാന സ്ഥാപനമാണിത്. സ്ട്രീം ഫയൽ പ്രതിനിധീകരിക്കുന്ന ഡാറ്റയാണ് ഉള്ളടക്കം. അതായത്, ഏകദേശം പറഞ്ഞാൽ, നിങ്ങൾ ഒരു ചതുരത്തിൽ നിന്ന് ഒരു ഫയൽ സ്വീകരിച്ച് മറ്റൊന്നിലേക്ക് മാറ്റുകയാണെങ്കിൽ, ഉള്ളടക്കം നിങ്ങളുടെ ഫയലായിരിക്കും.

നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, ഈ ചിത്രം പൊതുവായ പ്രക്രിയ കാണിക്കുന്നു. HandleHttpRequest - അഭ്യർത്ഥനകൾ സ്വീകരിക്കുന്നു, ReplaceText - ഒരു പ്രതികരണ ബോഡി സൃഷ്ടിക്കുന്നു, HandleHttpResponse - ഒരു പ്രതികരണം അയയ്ക്കുന്നു. FetchFile - ഒരു ഫയൽ സ്റ്റോറേജിൽ നിന്ന് ഒരു ഫയൽ സ്വീകരിക്കുന്നു, അത് PutSftp എന്ന ചതുരത്തിലേക്ക് മാറ്റുന്നു - ഈ ഫയൽ FTP-യിൽ, നിർദ്ദിഷ്ട വിലാസത്തിൽ ഇടുന്നു. ഇപ്പോൾ ഈ പ്രക്രിയയെക്കുറിച്ച് കൂടുതൽ.

ഈ സാഹചര്യത്തിൽ, അഭ്യർത്ഥനയാണ് എല്ലാറ്റിന്റെയും തുടക്കം. അതിന്റെ കോൺഫിഗറേഷൻ പാരാമീറ്ററുകൾ നോക്കാം.

StandardHttpContextMap ഒഴികെയുള്ള എല്ലാം ഇവിടെ വളരെ നിസ്സാരമാണ് - ഇത് അഭ്യർത്ഥനകൾ അയയ്‌ക്കാനും സ്വീകരിക്കാനും നിങ്ങളെ അനുവദിക്കുന്ന ഒരു തരത്തിലുള്ള സേവനമാണ്. കൂടുതൽ വിശദമായും ഉദാഹരണങ്ങൾക്കൊപ്പം പോലും, നിങ്ങൾക്ക് കാണാൻ കഴിയും - ഇവിടെ

അടുത്തതായി, ചതുരത്തിന്റെ ReplaceText കോൺഫിഗറേഷൻ പാരാമീറ്ററുകൾ നോക്കാം. ReplacementValue-ൽ ശ്രദ്ധിക്കുന്നത് മൂല്യവത്താണ് - ഇതാണ് പ്രതികരണത്തിന്റെ രൂപത്തിൽ ഉപയോക്താവിന് തിരികെ നൽകുന്നത്. ക്രമീകരണങ്ങളിൽ നിങ്ങൾക്ക് ലോഗിംഗ് ലെവൽ ക്രമീകരിക്കാൻ കഴിയും, നിങ്ങൾക്ക് ലോഗുകൾ {നിങ്ങൾ അൺപാക്ക് ചെയ്ത nifi}/nifi-1.9.2/logs കാണാനാകും, പരാജയം/വിജയ പാരാമീറ്ററുകളും ഉണ്ട് - ഈ പാരാമീറ്ററുകളെ അടിസ്ഥാനമാക്കി നിങ്ങൾക്ക് പ്രക്രിയ മൊത്തത്തിൽ നിയന്ത്രിക്കാനാകും. . അതായത്, വിജയകരമായ ടെക്സ്റ്റ് പ്രോസസ്സിംഗിന്റെ കാര്യത്തിൽ, ഉപയോക്താവിന് ഒരു പ്രതികരണം അയയ്ക്കുന്ന പ്രക്രിയയെ വിളിക്കും, മറ്റൊരു സാഹചര്യത്തിൽ ഞങ്ങൾ വിജയിക്കാത്ത പ്രക്രിയ ലോഗ് ചെയ്യും.

HandleHttpResponse പ്രോപ്പർട്ടികളിൽ ഒരു പ്രതികരണം വിജയകരമായി സൃഷ്‌ടിക്കുമ്പോൾ ഉള്ള സ്റ്റാറ്റസ് ഒഴികെ പ്രത്യേകിച്ച് രസകരമായ ഒന്നും തന്നെയില്ല.

ഞങ്ങൾ അഭ്യർത്ഥനയും പ്രതികരണവും ക്രമീകരിച്ചു - ഫയൽ സ്വീകരിച്ച് FTP സെർവറിൽ സ്ഥാപിക്കുന്നതിലേക്ക് പോകാം. FetchFile - ക്രമീകരണങ്ങളിൽ വ്യക്തമാക്കിയ പാതയിൽ ഒരു ഫയൽ സ്വീകരിക്കുകയും അടുത്ത പ്രക്രിയയിലേക്ക് അത് കൈമാറുകയും ചെയ്യുന്നു.

തുടർന്ന് PutSftp സ്ക്വയർ - ഫയൽ സംഭരണത്തിൽ ഫയൽ സ്ഥാപിക്കുന്നു. താഴെയുള്ള കോൺഫിഗറേഷൻ പാരാമീറ്ററുകൾ നമുക്ക് കാണാം.

ഓരോ സ്ക്വയറും സമാരംഭിക്കേണ്ട ഒരു പ്രത്യേക പ്രക്രിയയാണെന്ന വസ്തുത ശ്രദ്ധിക്കേണ്ടതാണ്. സങ്കീർണ്ണമായ ഇഷ്‌ടാനുസൃതമാക്കൽ ആവശ്യമില്ലാത്ത ഏറ്റവും ലളിതമായ ഉദാഹരണം ഞങ്ങൾ പരിശോധിച്ചു. അടുത്തതായി, ഞങ്ങൾ പ്രക്രിയയെ കുറച്ചുകൂടി സങ്കീർണ്ണമായി നോക്കും, അവിടെ ഞങ്ങൾ ഗ്രോവുകളിൽ അല്പം എഴുതും.

കൂടുതൽ സങ്കീർണ്ണമായ ഉദാഹരണം

SOAP സന്ദേശം പരിഷ്‌ക്കരിക്കുന്ന പ്രക്രിയ കാരണം ഉപഭോക്താവിലേക്കുള്ള ഡാറ്റ കൈമാറ്റ സേവനം കുറച്ചുകൂടി സങ്കീർണ്ണമായി മാറി. പൊതുവായ പ്രക്രിയ ചുവടെയുള്ള ചിത്രത്തിൽ കാണിച്ചിരിക്കുന്നു.

ഇവിടെ ആശയം പ്രത്യേകിച്ച് സങ്കീർണ്ണമല്ല: ഉപഭോക്താവിന് ഡാറ്റ ആവശ്യമാണെന്ന് ഞങ്ങൾക്ക് ഒരു അഭ്യർത്ഥന ലഭിച്ചു, അദ്ദേഹത്തിന് ഒരു സന്ദേശം ലഭിച്ചതായി ഒരു പ്രതികരണം അയച്ചു, പ്രതികരണ ഫയൽ സ്വീകരിക്കുന്നതിനുള്ള പ്രക്രിയ ആരംഭിച്ചു, തുടർന്ന് ഒരു നിശ്ചിത യുക്തി ഉപയോഗിച്ച് എഡിറ്റുചെയ്തു, തുടർന്ന് സെർവറിലേക്ക് ഒരു SOAP സന്ദേശത്തിന്റെ രൂപത്തിൽ ഫയൽ ഉപഭോക്താവിന് കൈമാറി.

ഞങ്ങൾ മുകളിൽ കണ്ട ആ സ്ക്വയറുകൾ വീണ്ടും വിവരിക്കേണ്ട ആവശ്യമില്ലെന്ന് ഞാൻ കരുതുന്നു - നമുക്ക് നേരിട്ട് പുതിയവയിലേക്ക് പോകാം. നിങ്ങൾക്ക് ഏതെങ്കിലും ഫയൽ എഡിറ്റ് ചെയ്യണമെങ്കിൽ സാധാരണ ReplaceText ടൈപ്പ് സ്‌ക്വയറുകൾ അനുയോജ്യമല്ലെങ്കിൽ, നിങ്ങളുടേതായ സ്‌ക്രിപ്റ്റ് എഴുതേണ്ടി വരും. ExecuteGroogyScript സ്ക്വയർ ഉപയോഗിച്ച് ഇത് ചെയ്യാൻ കഴിയും. അതിന്റെ ക്രമീകരണങ്ങൾ ചുവടെ അവതരിപ്പിച്ചിരിക്കുന്നു.

ഈ സ്‌ക്വയറിലേക്ക് സ്‌ക്രിപ്റ്റ് ലോഡുചെയ്യുന്നതിന് രണ്ട് ഓപ്ഷനുകൾ ഉണ്ട്. ഒരു സ്ക്രിപ്റ്റ് ഉള്ള ഒരു ഫയൽ ഡൗൺലോഡ് ചെയ്യുകയാണ് ആദ്യത്തേത്. രണ്ടാമത്തേത് scriptBody-യിലേക്ക് ഒരു സ്‌ക്രിപ്റ്റ് തിരുകിക്കൊണ്ടാണ്. എനിക്കറിയാവുന്നിടത്തോളം, എക്സിക്യൂട്ട്സ്ക്രിപ്റ്റ് സ്ക്വയർ നിരവധി ഭാഷകളെ പിന്തുണയ്ക്കുന്നു - അവയിലൊന്ന് ഗംഭീരമാണ്. ഞാൻ ജാവ ഡെവലപ്പർമാരെ നിരാശപ്പെടുത്തും - അത്തരം സ്ക്വയറുകളിൽ നിങ്ങൾക്ക് ജാവയിൽ സ്ക്രിപ്റ്റുകൾ എഴുതാൻ കഴിയില്ല. ശരിക്കും ആഗ്രഹിക്കുന്നവർക്കായി, നിങ്ങളുടേതായ ഇഷ്‌ടാനുസൃത സ്‌ക്വയർ സൃഷ്‌ടിച്ച് 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 അഭ്യർത്ഥനകൾ എങ്ങനെ അയയ്ക്കാം എന്നതിനെക്കുറിച്ചുള്ള കൂടുതൽ വിശദാംശങ്ങൾ നിങ്ങൾക്ക് കാണാൻ കഴിയും ഇവിടെ

NIFI പ്രോസസ്സുകൾ ഉപയോഗിക്കുന്നതിനുള്ള നിരവധി ഓപ്ഷനുകൾ ഞങ്ങൾ നോക്കി. അവർ എങ്ങനെ ഇടപഴകുന്നു, അവരുടെ യഥാർത്ഥ പ്രയോജനം എന്താണ്? പരിഗണിക്കപ്പെടുന്ന ഉദാഹരണങ്ങൾ പരീക്ഷണാത്മകമാണ്, പോരാട്ടത്തിൽ യഥാർത്ഥത്തിൽ സംഭവിക്കുന്നതിൽ നിന്ന് അല്പം വ്യത്യസ്തമാണ്. ഈ ലേഖനം ഡെവലപ്പർമാർക്ക് കുറച്ച് ഉപയോഗപ്രദമാകുമെന്ന് ഞാൻ പ്രതീക്ഷിക്കുന്നു. നിങ്ങളുടെ ശ്രദ്ധയ്ക്ക് നന്ദി. നിങ്ങൾക്ക് എന്തെങ്കിലും ചോദ്യങ്ങളുണ്ടെങ്കിൽ, എഴുതുക. ഞാൻ ഉത്തരം നൽകാൻ ശ്രമിക്കാം.

അവലംബം: www.habr.com