Apache NIFI - પ્રેક્ટિસમાં સુવિધાઓનું સંક્ષિપ્ત વિહંગાવલોકન

પરિચય

એવું બન્યું કે મારા વર્તમાન કાર્યસ્થળ પર મારે આ તકનીકથી પરિચિત થવું પડ્યું. હું થોડી પૃષ્ઠભૂમિ સાથે પ્રારંભ કરીશ. આગામી મીટિંગમાં, અમારી ટીમને કહેવામાં આવ્યું હતું કે અમારે સાથે એકીકરણ બનાવવાની જરૂર છે જાણીતી સિસ્ટમ. એકીકરણ દ્વારા તેનો અર્થ એવો હતો કે આ જાણીતી સિસ્ટમ અમને HTTP મારફતે ચોક્કસ અંતિમ બિંદુ પર વિનંતીઓ મોકલશે, અને અમે, વિચિત્ર રીતે, SOAP સંદેશના રૂપમાં જવાબો પાછા મોકલીશું. બધું સરળ અને તુચ્છ લાગે છે. આમાંથી તે નીચે મુજબ છે કે તમારે જરૂર છે ...

ઉદ્દેશ

3 સેવાઓ બનાવો. તેમાંથી પ્રથમ ડેટાબેઝ અપડેટ સેવા છે. આ સેવા, જ્યારે તૃતીય-પક્ષ સિસ્ટમમાંથી નવો ડેટા આવે છે, ત્યારે ડેટાબેઝમાં ડેટા અપડેટ કરે છે અને તેને આગલી સિસ્ટમમાં ટ્રાન્સફર કરવા માટે CSV ફોર્મેટમાં ફાઇલ જનરેટ કરે છે. બીજી સેવાના અંતિમ બિંદુને કહેવામાં આવે છે - FTP પરિવહન સેવા, જે સ્થાનાંતરિત ફાઇલ મેળવે છે, તેને માન્ય કરે છે અને FTP દ્વારા ફાઇલ સ્ટોરેજમાં મૂકે છે. ત્રીજી સેવા, ગ્રાહક ડેટા ટ્રાન્સફર સેવા, પ્રથમ બે સાથે અસુમેળ રીતે કામ કરે છે. તે ઉપર ચર્ચા કરેલ ફાઇલ મેળવવા માટે તૃતીય-પક્ષ બાહ્ય સિસ્ટમ તરફથી વિનંતી પ્રાપ્ત કરે છે, તૈયાર પ્રતિભાવ ફાઇલ લે છે, તેને સુધારે છે (ID, વર્ણન, LinkToFile ફીલ્ડ અપડેટ કરે છે) અને SOAP સંદેશના રૂપમાં પ્રતિસાદ મોકલે છે. એટલે કે, એકંદર ચિત્ર નીચે મુજબ છે: પ્રથમ બે સેવાઓ જ્યારે અપડેટ કરવા માટેનો ડેટા આવે ત્યારે જ તેમનું કાર્ય શરૂ કરે છે. ત્રીજી સેવા સતત કાર્ય કરે છે કારણ કે માહિતીના ઘણા ગ્રાહકો છે, પ્રતિ મિનિટ ડેટા માટે લગભગ 1000 વિનંતીઓ. સેવાઓ સતત ઉપલબ્ધ હોય છે અને તેમના ઉદાહરણો વિવિધ વાતાવરણમાં સ્થિત હોય છે, જેમ કે ટેસ્ટ, ડેમો, પ્રી-પ્રોડક્શન અને પ્રોડ. નીચે આ સેવાઓ કેવી રીતે કાર્ય કરે છે તેનો આકૃતિ છે. મને તરત જ સ્પષ્ટ કરવા દો કે બિનજરૂરી જટિલતા ટાળવા માટે કેટલીક વિગતોને સરળ બનાવવામાં આવી છે.

ટેકનિકલ ડીપનિંગ

સમસ્યાના ઉકેલનું આયોજન કરતી વખતે, અમે સૌપ્રથમ સ્પ્રિંગ ફ્રેમવર્ક, Nginx બેલેન્સર, પોસ્ટગ્રેસ ડેટાબેઝ અને અન્ય ટેકનિકલ વસ્તુઓનો ઉપયોગ કરીને જાવામાં એપ્લિકેશન્સ બનાવવાનું નક્કી કર્યું છે અને તેટલી ટેકનિકલ વસ્તુઓ નથી. ટેકનિકલ સોલ્યુશન વિકસાવવાનો સમય અમને આ સમસ્યાને ઉકેલવા માટે અન્ય અભિગમો પર વિચાર કરવાની મંજૂરી આપે છે, અમારી નજર Apache NIFI તકનીક પર પડી, જે ચોક્કસ વર્તુળોમાં ફેશનેબલ છે. હું તરત જ કહીશ કે આ ટેક્નોલોજીએ અમને આ 3 સેવાઓની નોંધ લેવાની મંજૂરી આપી. આ લેખ ઉપભોક્તા માટે ફાઇલ પરિવહન સેવા અને ડેટા ટ્રાન્સફર સેવાના વિકાસનું વર્ણન કરશે, પરંતુ જો લેખ ઉપયોગી છે, તો હું ડેટાબેઝમાં ડેટા અપડેટ કરવા માટેની સેવા વિશે લખીશ.

તે શું છે?

NIFI એ ડેટાના ઝડપી સમાંતર લોડિંગ અને પ્રોસેસિંગ માટે વિતરિત આર્કિટેક્ચર છે, સ્ત્રોતો અને રૂપાંતરણો માટે મોટી સંખ્યામાં પ્લગિન્સ, રૂપરેખાંકનોનું સંસ્કરણ અને ઘણું બધું. એક સરસ બોનસ એ છે કે તેનો ઉપયોગ કરવો ખૂબ જ સરળ છે. નજીવી પ્રક્રિયાઓ જેમ કે getFile, sendHttpRequest અને અન્યને ચોરસ તરીકે રજૂ કરી શકાય છે. દરેક ચોરસ એક પ્રક્રિયાનું પ્રતિનિધિત્વ કરે છે, જેની ક્રિયાપ્રતિક્રિયા નીચેની આકૃતિમાં જોઈ શકાય છે. પ્રક્રિયા સેટઅપ ક્રિયાપ્રતિક્રિયાઓ પર વધુ વિગતવાર દસ્તાવેજો લખવામાં આવ્યા છે અહીં , જેઓ રશિયન બોલે છે તેમના માટે - અહીં. દસ્તાવેજીકરણ સંપૂર્ણ રીતે વર્ણવે છે કે કેવી રીતે NIFI ને કેવી રીતે અનપૅક કરવું અને ચલાવવું, તેમજ પ્રક્રિયાઓ કેવી રીતે બનાવવી, જેને સ્ક્વેર તરીકે પણ ઓળખવામાં આવે છે.
લેખ લખવાનો વિચાર એક લાંબી શોધ અને પ્રાપ્ત માહિતીને કંઈક સભાન સ્વરૂપમાં સંરચિત કર્યા પછી જન્મ્યો હતો, તેમજ ભાવિ વિકાસકર્તાઓ માટે જીવન થોડું સરળ બનાવવાની ઇચ્છા.

ઉદાહરણ:

ચોરસ એકબીજા સાથે કેવી રીતે ક્રિયાપ્રતિક્રિયા કરે છે તેનું ઉદાહરણ ગણવામાં આવે છે. સામાન્ય યોજના એકદમ સરળ છે: અમે એક HTTP વિનંતી પ્રાપ્ત કરીએ છીએ (સિદ્ધાંતમાં, વિનંતીના મુખ્ય ભાગમાં ફાઇલ સાથે. NIFI ની ક્ષમતાઓ દર્શાવવા માટે, આ ઉદાહરણમાં વિનંતી સ્થાનિક ફાઇલ સ્ટોરેજમાંથી ફાઇલ પ્રાપ્ત કરવાની પ્રક્રિયા શરૂ કરે છે. ), પછી અમે એક પ્રતિભાવ પાછો મોકલીએ છીએ કે વિનંતી પ્રાપ્ત થઈ છે, સમાંતર રીતે FH તરફથી ફાઇલ પ્રાપ્ત કરવાની પ્રક્રિયા અને પછી FTP દ્વારા FH પર ખસેડવાની પ્રક્રિયા. તે સ્પષ્ટ કરવા યોગ્ય છે કે પ્રક્રિયાઓ કહેવાતા ફ્લોફાઇલ દ્વારા એકબીજા સાથે ક્રિયાપ્રતિક્રિયા કરે છે. આ NIFI માં બેઝ એન્ટિટી છે જે વિશેષતાઓ અને સામગ્રીનો સંગ્રહ કરે છે. સામગ્રી એ ડેટા છે જે સ્ટ્રીમ ફાઇલ દ્વારા દર્શાવવામાં આવે છે. એટલે કે, આશરે કહીએ તો, જો તમે એક ચોરસમાંથી ફાઇલ મેળવો છો અને તેને બીજામાં સ્થાનાંતરિત કરો છો, તો સામગ્રી તમારી ફાઇલ હશે.

જેમ તમે જોઈ શકો છો, આ ચિત્ર સામાન્ય પ્રક્રિયા બતાવે છે. HandleHttpRequest - વિનંતીઓ સ્વીકારે છે, ReplaceText - પ્રતિભાવ બોડી જનરેટ કરે છે, HandleHttpResponse - પ્રતિભાવ મોકલે છે. FetchFile - ફાઇલ સ્ટોરેજમાંથી ફાઇલ મેળવે છે, તેને ચોરસ PutSftp પર સ્થાનાંતરિત કરે છે - આ ફાઇલને FTP પર, ઉલ્લેખિત સરનામા પર મૂકે છે. હવે આ પ્રક્રિયા વિશે વધુ.

આ કિસ્સામાં, વિનંતી એ દરેક વસ્તુની શરૂઆત છે. ચાલો તેના રૂપરેખાંકન પરિમાણો જોઈએ.

StandardHttpContextMap ના અપવાદ સિવાય અહીં બધું જ નજીવું છે - આ એક પ્રકારની સેવા છે જે તમને વિનંતીઓ મોકલવા અને પ્રાપ્ત કરવાની મંજૂરી આપે છે. વધુ વિગતવાર અને ઉદાહરણો સાથે પણ, તમે જોઈ શકો છો - અહીં

આગળ, ચાલો સ્ક્વેરના ReplaceText રૂપરેખાંકન પરિમાણો જોઈએ. રિપ્લેસમેન્ટ વેલ્યુ પર ધ્યાન આપવું યોગ્ય છે - આ તે છે જે પ્રતિસાદના રૂપમાં વપરાશકર્તાને પરત કરવામાં આવશે. સેટિંગ્સમાં તમે લોગીંગના સ્તરને સમાયોજિત કરી શકો છો, તમે લોગ જોઈ શકો છો {જ્યાં તમે nifi-1.9.2/logs અનપેક કર્યું છે, ત્યાં નિષ્ફળતા/સફળતાના પરિમાણો પણ છે - આ પરિમાણોના આધારે તમે સમગ્ર પ્રક્રિયાને નિયંત્રિત કરી શકો છો. . એટલે કે, સફળ ટેક્સ્ટ પ્રોસેસિંગના કિસ્સામાં, વપરાશકર્તાને પ્રતિસાદ મોકલવાની પ્રક્રિયાને બોલાવવામાં આવશે, અને અન્ય કિસ્સામાં અમે ફક્ત અસફળ પ્રક્રિયાને લૉગ કરીશું.

HandleHttpResponse પ્રોપર્ટીઝમાં જ્યારે પ્રતિભાવ સફળતાપૂર્વક બનાવવામાં આવે ત્યારે સ્ટેટસ સિવાય કંઈ ખાસ રસપ્રદ નથી.

અમે વિનંતી અને પ્રતિસાદને ક્રમમાં ગોઠવી દીધો છે - ચાલો ફાઇલ પ્રાપ્ત કરવા અને તેને FTP સર્વર પર મૂકવા તરફ આગળ વધીએ. FetchFile - સેટિંગ્સમાં ઉલ્લેખિત પાથ પર ફાઇલ મેળવે છે અને તેને આગલી પ્રક્રિયામાં પસાર કરે છે.

અને પછી PutSftp ચોરસ - ફાઇલને ફાઇલ સ્ટોરેજમાં મૂકે છે. અમે નીચે રૂપરેખાંકન પરિમાણો જોઈ શકીએ છીએ.

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

વધુ જટિલ ઉદાહરણ

SOAP સંદેશને સંશોધિત કરવાની પ્રક્રિયાને કારણે ગ્રાહકને ડેટા ટ્રાન્સફર સેવા થોડી વધુ જટિલ બની. સામાન્ય પ્રક્રિયા નીચેની આકૃતિમાં બતાવવામાં આવી છે.

અહીં વિચાર પણ ખાસ જટિલ નથી: અમને ઉપભોક્તા તરફથી વિનંતી મળી કે તેને ડેટાની જરૂર છે, એક પ્રતિસાદ મોકલ્યો કે તેને એક સંદેશ મળ્યો છે, પ્રતિભાવ ફાઇલ પ્રાપ્ત કરવાની પ્રક્રિયા શરૂ કરી, પછી તેને ચોક્કસ તર્ક સાથે સંપાદિત કરો, અને પછી સર્વર પર SOAP સંદેશના રૂપમાં ગ્રાહકને ફાઇલ ટ્રાન્સફર કરી.

મને લાગે છે કે આપણે ઉપર જોયેલા ચોરસનું ફરીથી વર્ણન કરવાની જરૂર નથી - ચાલો સીધા નવા તરફ આગળ વધીએ. જો તમારે કોઈપણ ફાઇલમાં ફેરફાર કરવાની જરૂર હોય અને સામાન્ય રિપ્લેસ ટેક્સ્ટ પ્રકારના ચોરસ યોગ્ય ન હોય, તો તમારે તમારી પોતાની સ્ક્રિપ્ટ લખવી પડશે. આ ExecuteGroogyScript ચોરસનો ઉપયોગ કરીને કરી શકાય છે. તેની સેટિંગ્સ નીચે પ્રસ્તુત છે.

આ સ્ક્વેરમાં સ્ક્રિપ્ટ લોડ કરવા માટે બે વિકલ્પો છે. પ્રથમ સ્ક્રિપ્ટ સાથે ફાઇલ ડાઉનલોડ કરીને છે. બીજું સ્ક્રિપ્ટબોડીમાં સ્ક્રિપ્ટ દાખલ કરીને છે. જ્યાં સુધી હું જાણું છું, એક્ઝિક્યુટસ્ક્રિપ્ટ સ્ક્વેર ઘણી ભાષાઓને સપોર્ટ કરે છે - તેમાંથી એક ગ્રુવી છે. હું જાવા વિકાસકર્તાઓને નિરાશ કરીશ - તમે આવા ચોરસમાં જાવામાં સ્ક્રિપ્ટો લખી શકતા નથી. જેઓ ખરેખર કરવા માંગે છે, તમારે તમારો પોતાનો કસ્ટમ સ્ક્વેર બનાવવાની અને તેને NIFI સિસ્ટમમાં ઉમેરવાની જરૂર છે. આ આખું ઑપરેશન એક ખંજરી સાથે ખૂબ લાંબા નૃત્ય સાથે છે, જેની સાથે આપણે આ લેખમાં વ્યવહાર કરીશું નહીં. મેં ગ્રુવી ભાષા પસંદ કરી. નીચે એક પરીક્ષણ સ્ક્રિપ્ટ છે જે SOAP સંદેશમાં id ને વધારાના રૂપે અપડેટ કરે છે. તે નોંધવું મહત્વપૂર્ણ છે. તમે ફ્લોફાઇલમાંથી ફાઇલ લો અને તેને અપડેટ કરો, ભૂલશો નહીં કે તમારે તેને ત્યાં પાછું મૂકવાની જરૂર છે, અપડેટ. એ નોંધવું પણ યોગ્ય છે કે તમામ પુસ્તકાલયોનો સમાવેશ થતો નથી. એવું બની શકે છે કે તમારે હજુ પણ એક લિબ આયાત કરવું પડશે. અન્ય નુકસાન એ છે કે આ સ્ક્વેરની સ્ક્રિપ્ટ ડીબગ કરવી ખૂબ મુશ્કેલ છે. 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 છે.

યજમાન અને ક્રિયા (સોપએક્શન) જેવા ઘણા ગુણધર્મો ઉમેરો. અમે સાચવીએ છીએ અને તપાસીએ છીએ. તમે SOAP વિનંતીઓ કેવી રીતે મોકલવી તે વિશે વધુ વિગતો જોઈ શકો છો અહીં

અમે NIFI પ્રક્રિયાઓનો ઉપયોગ કરવા માટે ઘણા વિકલ્પો જોયા. તેઓ કેવી રીતે ક્રિયાપ્રતિક્રિયા કરે છે અને તેમનો વાસ્તવિક લાભ શું છે? ધ્યાનમાં લેવાયેલા ઉદાહરણો કસોટીના છે અને વાસ્તવમાં લડાઇમાં જે થાય છે તેના કરતા થોડા અલગ છે. મને આશા છે કે આ લેખ વિકાસકર્તાઓ માટે થોડો ઉપયોગી થશે. તમારા ધ્યાન બદલ આભાર. જો તમને કોઈ પ્રશ્નો હોય, તો લખો. હું જવાબ આપવાનો પ્રયત્ન કરીશ.

સોર્સ: www.habr.com