હેલો દરેક!

કાર્ય નીચે મુજબ છે - ઉપરના ચિત્રમાં એક પ્રવાહ દર્શાવેલ છે, જેને N સર્વર્સ પર રોલઆઉટ કરવાની જરૂર છે અપાચે NiFi. ફ્લો ટેસ્ટ - એક ફાઇલ જનરેટ કરવામાં આવી રહી છે અને અન્ય 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é પર અને માહિતી સમસ્યા હલ કરવા માટે પૂરતી છે. 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 ઉદાહરણને હોસ્ટ તરીકે સ્પષ્ટ કરી શકાય છે કે જેના પર આપણે પ્રક્રિયા જૂથને રોલ કરીએ છીએ.

પ્રક્રિયા જૂથને અટકાવેલ પ્રોસેસર્સ સાથે ઉમેરવામાં આવ્યું છે, તેમને શરૂ કરવાની જરૂર છે

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

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 લાઇબ્રેરીના ડેવલપરને લખવાનું અને સલાહ/સહાય માટે પૂછવાનું નક્કી કર્યું. વિકાસકર્તાએ મને જવાબ આપ્યો, અમે સમસ્યાની ચર્ચા કરી અને તેણે લખ્યું કે તેને "કંઈક તપાસવા" માટે સમયની જરૂર છે. અને હવે, થોડા દિવસો પછી, એક ઇમેઇલ આવે છે જેમાં Python ફંક્શન લખેલું છે જે મારી સ્ટાર્ટઅપ સમસ્યાને હલ કરે છે !!! તે સમયે, NiPyAPI સંસ્કરણ 0.13.3 હતું અને, અલબત્ત, તેમાં આ પ્રકારનું કંઈ નહોતું. પરંતુ સંસ્કરણ 0.14.0 માં, જે તાજેતરમાં જ બહાર પાડવામાં આવ્યું હતું, આ કાર્ય પહેલેથી જ પુસ્તકાલયમાં શામેલ છે. મળો

nipyapi.canvas.set_remote_process_group_transmission

તેથી, NiPyAPI લાઇબ્રેરીની મદદથી, અમે રજિસ્ટ્રીને કનેક્ટ કરી, ફ્લો રોલ અપ કર્યો અને પ્રોસેસર્સ અને ડેટા ટ્રાન્સફર પણ શરૂ કર્યા. પછી તમે કોડને કાંસકો કરી શકો છો, તમામ પ્રકારના ચેક ઉમેરી શકો છો, લોગિંગ કરી શકો છો અને બસ. પરંતુ તે સંપૂર્ણપણે અલગ વાર્તા છે.

મેં ધ્યાનમાં લીધેલા ઓટોમેશન વિકલ્પોમાંથી, બાદમાં મને સૌથી વધુ કાર્યક્ષમ લાગતું હતું. પ્રથમ, આ હજુ પણ પાયથોન કોડ છે, જેમાં તમે સહાયક પ્રોગ્રામ કોડને એમ્બેડ કરી શકો છો અને પ્રોગ્રામિંગ ભાષાનો સંપૂર્ણ લાભ લઈ શકો છો. બીજું, NiPyAPI પ્રોજેક્ટ સક્રિય રીતે વિકાસ કરી રહ્યો છે અને સમસ્યાઓના કિસ્સામાં તમે વિકાસકર્તાને લખી શકો છો. ત્રીજે સ્થાને, NiPyAPI એ હજુ પણ જટિલ સમસ્યાઓ ઉકેલવા માટે NiFi સાથે ક્રિયાપ્રતિક્રિયા કરવા માટે વધુ લવચીક સાધન છે. ઉદાહરણ તરીકે, પ્રવાહમાં સંદેશ કતાર હાલમાં ખાલી છે કે કેમ તે નક્કી કરવા અને પ્રક્રિયા જૂથને અપડેટ કરવું શક્ય છે કે કેમ.

બસ એટલું જ. મેં NiFi માં ફ્લો ડિલિવરીને સ્વચાલિત કરવા માટેના 3 અભિગમો વર્ણવ્યા છે, જે મુશ્કેલીઓ કે જે વિકાસકર્તાને આવી શકે છે અને સ્વચાલિત ડિલિવરી માટે કાર્યકારી કોડ પ્રદાન કર્યો છે. જો તમને આ વિષયમાં મારી જેમ જ રસ હોય તો - લખો!

સોર્સ: www.habr.com