Apache 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 இல் கவனம் செலுத்துவது மதிப்பு - இதுவே பயனருக்கு பதிலின் வடிவத்தில் திருப்பித் தரப்படும். அமைப்புகளில் நீங்கள் பதிவு செய்யும் அளவை சரிசெய்யலாம், நீங்கள் பதிவுகளை {நிஃபை-1.9.2/logs ஐத் திறக்கும் இடத்தில் பார்க்கலாம், தோல்வி/வெற்றி அளவுருக்களும் உள்ளன - இந்த அளவுருக்களின் அடிப்படையில் நீங்கள் செயல்முறையை முழுவதுமாக ஒழுங்குபடுத்தலாம். . அதாவது, வெற்றிகரமான உரை செயலாக்கத்தில், பயனருக்கு பதிலை அனுப்பும் செயல்முறை அழைக்கப்படும், மற்றொரு வழக்கில் தோல்வியுற்ற செயல்முறையை வெறுமனே பதிவு செய்வோம்.

HandleHttpResponse பண்புகளில் பதிலை வெற்றிகரமாக உருவாக்கும் நிலையைத் தவிர, குறிப்பாக சுவாரஸ்யமான எதுவும் இல்லை.

கோரிக்கை மற்றும் பதிலை நாங்கள் வரிசைப்படுத்தியுள்ளோம் - கோப்பைப் பெற்று அதை FTP சேவையகத்தில் வைப்பதற்குச் செல்லலாம். FetchFile - அமைப்புகளில் குறிப்பிடப்பட்ட பாதையில் ஒரு கோப்பைப் பெற்று அடுத்த செயல்முறைக்கு அனுப்புகிறது.

பின்னர் PutSftp சதுரம் - கோப்பை கோப்பு சேமிப்பகத்தில் வைக்கிறது. கீழே உள்ள கட்டமைப்பு அளவுருக்களை நாம் பார்க்கலாம்.

ஒவ்வொரு சதுரமும் தொடங்கப்பட வேண்டிய ஒரு தனி செயல்முறை என்பதில் கவனம் செலுத்துவது மதிப்பு. சிக்கலான தனிப்பயனாக்கம் தேவைப்படாத எளிய உதாரணத்தைப் பார்த்தோம். அடுத்து, செயல்முறையை இன்னும் கொஞ்சம் சிக்கலானதாகப் பார்ப்போம், அங்கு பள்ளங்களில் சிறிது எழுதுவோம்.

மிகவும் சிக்கலான உதாரணம்

SOAP செய்தியை மாற்றியமைக்கும் செயல்முறையின் காரணமாக நுகர்வோருக்கு தரவு பரிமாற்ற சேவை சற்று சிக்கலானதாக மாறியது. பொதுவான செயல்முறை கீழே உள்ள படத்தில் காட்டப்பட்டுள்ளது.

இங்கே யோசனையும் குறிப்பாக சிக்கலானது அல்ல: நுகர்வோரிடமிருந்து தரவு தேவை என்று ஒரு கோரிக்கையைப் பெற்றோம், அவர் ஒரு செய்தியைப் பெற்றதாக ஒரு பதிலை அனுப்பினார், மறுமொழி கோப்பைப் பெறுவதற்கான செயல்முறையைத் தொடங்கினார், பின்னர் அதை ஒரு குறிப்பிட்ட தர்க்கத்துடன் திருத்தினார், பின்னர் SOAP செய்தியின் வடிவில் நுகர்வோருக்கு கோப்பை சேவையகத்திற்கு மாற்றியது.

நாம் மேலே பார்த்த அந்த சதுரங்களை மீண்டும் விவரிக்க வேண்டிய அவசியமில்லை என்று நினைக்கிறேன் - நேராக புதியவற்றுக்கு செல்லலாம். நீங்கள் எந்த கோப்பையும் திருத்த வேண்டும் மற்றும் சாதாரண ReplaceText வகை சதுரங்கள் பொருந்தவில்லை என்றால், நீங்கள் உங்கள் சொந்த ஸ்கிரிப்டை எழுத வேண்டும். ExecuteGroogyScript சதுரத்தைப் பயன்படுத்தி இதைச் செய்யலாம். அதன் அமைப்புகள் கீழே கொடுக்கப்பட்டுள்ளன.

இந்த சதுரத்தில் ஸ்கிரிப்டை ஏற்றுவதற்கு இரண்டு விருப்பங்கள் உள்ளன. முதலாவது ஸ்கிரிப்ட் கொண்ட கோப்பைப் பதிவிறக்குவது. இரண்டாவது ஸ்கிரிப்ட் பாடியில் ஸ்கிரிப்டைச் செருகுவது. எனக்குத் தெரிந்தவரை, executeScript சதுரம் பல மொழிகளை ஆதரிக்கிறது - அவற்றில் ஒன்று க்ரூவி. நான் ஜாவா டெவலப்பர்களை ஏமாற்றுவேன் - நீங்கள் ஜாவாவில் ஸ்கிரிப்ட்களை அத்தகைய சதுரங்களில் எழுத முடியாது. உண்மையில் விரும்புவோருக்கு, உங்கள் சொந்த தனிப்பயன் சதுரத்தை உருவாக்கி அதை NIFI அமைப்பில் சேர்க்க வேண்டும். இந்த முழு செயல்பாடும் ஒரு டம்போரைனுடன் ஒரு நீண்ட நடனத்துடன் உள்ளது, இந்த கட்டுரையில் நாம் சமாளிக்க மாட்டோம். நான் க்ரூவி மொழியை தேர்ந்தெடுத்தேன். SOAP செய்தியில் ஐடியை எளிமையாகப் புதுப்பிக்கும் சோதனை ஸ்கிரிப்ட் கீழே உள்ளது. கவனிக்க வேண்டியது அவசியம். நீங்கள் ஃப்ளோஃபைலில் இருந்து கோப்பை எடுத்து அதைப் புதுப்பிக்கிறீர்கள், அதை மீண்டும் அங்கேயே வைக்க வேண்டும் என்பதை மறந்துவிடாதீர்கள், புதுப்பிக்கப்பட்டது. அனைத்து நூலகங்களும் சேர்க்கப்படவில்லை என்பதும் குறிப்பிடத்தக்கது. நீங்கள் இன்னும் லிப்களில் ஒன்றை இறக்குமதி செய்ய வேண்டியிருக்கும். மற்றொரு குறைபாடு என்னவென்றால், இந்த சதுரத்தில் உள்ள ஸ்கிரிப்டை பிழைத்திருத்துவது மிகவும் கடினம். NIFI JVM உடன் இணைக்க மற்றும் பிழைத்திருத்த செயல்முறையைத் தொடங்க ஒரு வழி உள்ளது. தனிப்பட்ட முறையில், நான் ஒரு உள்ளூர் பயன்பாட்டைத் தொடங்கினேன் மற்றும் அமர்விலிருந்து ஒரு கோப்பைப் பெறுவதை உருவகப்படுத்தினேன். நான் உள்ளூரில் பிழைத்திருத்தமும் செய்தேன். ஸ்கிரிப்டை ஏற்றும்போது தோன்றும் பிழைகள் கூகுளுக்கு மிகவும் எளிதானது மற்றும் பதிவில் 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 செய்தி அனுப்பப்படும் முறையை நாங்கள் விவரிக்கிறோம். எங்கே எழுதுகிறோம். அடுத்து இது சோப் என்று குறிப்பிட வேண்டும்.

புரவலன் மற்றும் செயல் (soapAction) போன்ற பல பண்புகளைச் சேர்க்கவும். நாங்கள் சேமித்து சரிபார்க்கிறோம். SOAP கோரிக்கைகளை எவ்வாறு அனுப்புவது என்பது பற்றிய கூடுதல் விவரங்களை நீங்கள் பார்க்கலாம் இங்கே

NIFI செயல்முறைகளைப் பயன்படுத்துவதற்கான பல விருப்பங்களைப் பார்த்தோம். அவர்கள் எவ்வாறு தொடர்பு கொள்கிறார்கள் மற்றும் அவர்களின் உண்மையான நன்மை என்ன? பரிசீலிக்கப்பட்ட எடுத்துக்காட்டுகள் சோதனையானவை மற்றும் உண்மையில் போரில் என்ன நடக்கிறது என்பதில் இருந்து சற்று வித்தியாசமானது. இந்த கட்டுரை டெவலப்பர்களுக்கு கொஞ்சம் பயனுள்ளதாக இருக்கும் என்று நம்புகிறேன். உங்கள் கவனத்திற்கு நன்றி. உங்களிடம் ஏதேனும் கேள்விகள் இருந்தால், எழுதுங்கள். பதில் சொல்ல முயற்சிக்கிறேன்.

ஆதாரம்: www.habr.com