ਅਪਾਚੇ NIFI - ਅਭਿਆਸ ਵਿੱਚ ਮੌਕਿਆਂ ਦੀ ਇੱਕ ਸੰਖੇਪ ਜਾਣਕਾਰੀ

ਜਾਣ ਪਛਾਣ

ਇਹ ਇਸ ਤਰ੍ਹਾਂ ਹੋਇਆ ਕਿ ਮੇਰੇ ਮੌਜੂਦਾ ਕੰਮ ਵਾਲੀ ਥਾਂ 'ਤੇ ਮੈਨੂੰ ਇਸ ਤਕਨਾਲੋਜੀ ਨਾਲ ਜਾਣੂ ਹੋਣਾ ਪਿਆ. ਮੈਂ ਥੋੜ੍ਹੇ ਜਿਹੇ ਪਿਛੋਕੜ ਨਾਲ ਸ਼ੁਰੂ ਕਰਾਂਗਾ। ਅਗਲੀ ਮੀਟਿੰਗ ਵਿੱਚ, ਸਾਡੀ ਟੀਮ ਨੂੰ ਦੱਸਿਆ ਗਿਆ ਕਿ ਸਾਨੂੰ ਨਾਲ ਏਕੀਕਰਨ ਬਣਾਉਣ ਦੀ ਲੋੜ ਹੈ ਜਾਣਿਆ ਸਿਸਟਮ. ਏਕੀਕਰਣ ਦੁਆਰਾ ਇਸਦਾ ਮਤਲਬ ਇਹ ਸੀ ਕਿ ਇਹ ਜਾਣਿਆ-ਪਛਾਣਿਆ ਸਿਸਟਮ ਸਾਨੂੰ HTTP ਦੁਆਰਾ ਇੱਕ ਖਾਸ ਅੰਤਮ ਬਿੰਦੂ ਤੇ ਬੇਨਤੀਆਂ ਭੇਜੇਗਾ, ਅਤੇ ਅਸੀਂ, ਅਜੀਬ ਤੌਰ 'ਤੇ, ਇੱਕ SOAP ਸੰਦੇਸ਼ ਦੇ ਰੂਪ ਵਿੱਚ ਜਵਾਬ ਵਾਪਸ ਭੇਜਾਂਗੇ। ਹਰ ਚੀਜ਼ ਸਧਾਰਨ ਅਤੇ ਮਾਮੂਲੀ ਜਾਪਦੀ ਹੈ. ਇਸ ਤੋਂ ਇਹ ਪਤਾ ਚੱਲਦਾ ਹੈ ਕਿ ਤੁਹਾਨੂੰ ਲੋੜ ਹੈ ...

ਉਦੇਸ਼

3 ਸੇਵਾਵਾਂ ਬਣਾਓ। ਇਹਨਾਂ ਵਿੱਚੋਂ ਪਹਿਲੀ ਡਾਟਾਬੇਸ ਅੱਪਡੇਟ ਸੇਵਾ ਹੈ। ਇਹ ਸੇਵਾ, ਜਦੋਂ ਇੱਕ ਤੀਜੀ-ਧਿਰ ਸਿਸਟਮ ਤੋਂ ਨਵਾਂ ਡੇਟਾ ਆਉਂਦਾ ਹੈ, ਡੇਟਾਬੇਸ ਵਿੱਚ ਡੇਟਾ ਨੂੰ ਅਪਡੇਟ ਕਰਦੀ ਹੈ ਅਤੇ ਇਸਨੂੰ ਅਗਲੇ ਸਿਸਟਮ ਵਿੱਚ ਟ੍ਰਾਂਸਫਰ ਕਰਨ ਲਈ CSV ਫਾਰਮੈਟ ਵਿੱਚ ਇੱਕ ਫਾਈਲ ਤਿਆਰ ਕਰਦੀ ਹੈ। ਦੂਜੀ ਸੇਵਾ ਦੇ ਅੰਤਮ ਬਿੰਦੂ ਨੂੰ ਕਿਹਾ ਜਾਂਦਾ ਹੈ - FTP ਟ੍ਰਾਂਸਪੋਰਟ ਸੇਵਾ, ਜੋ ਟ੍ਰਾਂਸਫਰ ਕੀਤੀ ਫਾਈਲ ਪ੍ਰਾਪਤ ਕਰਦੀ ਹੈ, ਇਸਨੂੰ ਪ੍ਰਮਾਣਿਤ ਕਰਦੀ ਹੈ, ਅਤੇ ਇਸਨੂੰ FTP ਦੁਆਰਾ ਫਾਈਲ ਸਟੋਰੇਜ ਵਿੱਚ ਰੱਖਦੀ ਹੈ। ਤੀਜੀ ਸੇਵਾ, ਉਪਭੋਗਤਾ ਡੇਟਾ ਟ੍ਰਾਂਸਫਰ ਸੇਵਾ, ਪਹਿਲੇ ਦੋ ਨਾਲ ਅਸਿੰਕਰੋਨਸ ਤੌਰ 'ਤੇ ਕੰਮ ਕਰਦੀ ਹੈ। ਇਹ ਉੱਪਰ ਚਰਚਾ ਕੀਤੀ ਗਈ ਫਾਈਲ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਇੱਕ ਤੀਜੀ-ਧਿਰ ਦੇ ਬਾਹਰੀ ਸਿਸਟਮ ਤੋਂ ਇੱਕ ਬੇਨਤੀ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ, ਤਿਆਰ ਜਵਾਬ ਫਾਈਲ ਲੈਂਦਾ ਹੈ, ਇਸਨੂੰ ਸੋਧਦਾ ਹੈ (ਆਈਡੀ, ਵਰਣਨ, ਲਿੰਕ ਟੂਫਾਈਲ ਖੇਤਰਾਂ ਨੂੰ ਅੱਪਡੇਟ ਕਰਦਾ ਹੈ) ਅਤੇ ਇੱਕ SOAP ਸੰਦੇਸ਼ ਦੇ ਰੂਪ ਵਿੱਚ ਜਵਾਬ ਭੇਜਦਾ ਹੈ। ਭਾਵ, ਸਮੁੱਚੀ ਤਸਵੀਰ ਇਸ ਪ੍ਰਕਾਰ ਹੈ: ਪਹਿਲੀਆਂ ਦੋ ਸੇਵਾਵਾਂ ਉਦੋਂ ਹੀ ਆਪਣਾ ਕੰਮ ਸ਼ੁਰੂ ਕਰਦੀਆਂ ਹਨ ਜਦੋਂ ਅਪਡੇਟ ਕਰਨ ਲਈ ਡੇਟਾ ਆ ਜਾਂਦਾ ਹੈ। ਤੀਜੀ ਸੇਵਾ ਲਗਾਤਾਰ ਕੰਮ ਕਰਦੀ ਹੈ ਕਿਉਂਕਿ ਜਾਣਕਾਰੀ ਦੇ ਬਹੁਤ ਸਾਰੇ ਖਪਤਕਾਰ ਹਨ, ਪ੍ਰਤੀ ਮਿੰਟ ਡੇਟਾ ਲਈ ਲਗਭਗ 1000 ਬੇਨਤੀਆਂ. ਸੇਵਾਵਾਂ ਨਿਰੰਤਰ ਉਪਲਬਧ ਹੁੰਦੀਆਂ ਹਨ ਅਤੇ ਉਹਨਾਂ ਦੀਆਂ ਉਦਾਹਰਣਾਂ ਵੱਖ-ਵੱਖ ਵਾਤਾਵਰਣਾਂ ਵਿੱਚ ਸਥਿਤ ਹੁੰਦੀਆਂ ਹਨ, ਜਿਵੇਂ ਕਿ ਟੈਸਟ, ਡੈਮੋ, ਪ੍ਰੀ-ਪ੍ਰੋਡਕਸ਼ਨ ਅਤੇ ਉਤਪਾਦ। ਹੇਠਾਂ ਇੱਕ ਚਿੱਤਰ ਹੈ ਕਿ ਇਹ ਸੇਵਾਵਾਂ ਕਿਵੇਂ ਕੰਮ ਕਰਦੀਆਂ ਹਨ। ਮੈਂ ਤੁਰੰਤ ਸਪਸ਼ਟ ਕਰ ਦਿੰਦਾ ਹਾਂ ਕਿ ਬੇਲੋੜੀ ਗੁੰਝਲਤਾ ਤੋਂ ਬਚਣ ਲਈ ਕੁਝ ਵੇਰਵਿਆਂ ਨੂੰ ਸਰਲ ਬਣਾਇਆ ਗਿਆ ਹੈ।

ਤਕਨੀਕੀ ਡੂੰਘਾਈ

ਸਮੱਸਿਆ ਦੇ ਹੱਲ ਦੀ ਯੋਜਨਾ ਬਣਾਉਣ ਵੇਲੇ, ਅਸੀਂ ਪਹਿਲਾਂ ਜਾਵਾ ਵਿੱਚ ਸਪਰਿੰਗ ਫਰੇਮਵਰਕ, Nginx ਬੈਲੈਂਸਰ, ਪੋਸਟਗ੍ਰੇਸ ਡੇਟਾਬੇਸ ਅਤੇ ਹੋਰ ਤਕਨੀਕੀ ਚੀਜ਼ਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਐਪਲੀਕੇਸ਼ਨ ਬਣਾਉਣ ਦਾ ਫੈਸਲਾ ਕੀਤਾ ਹੈ ਨਾ ਕਿ ਤਕਨੀਕੀ ਚੀਜ਼ਾਂ। ਤਕਨੀਕੀ ਹੱਲ ਵਿਕਸਿਤ ਕਰਨ ਦੇ ਸਮੇਂ ਤੋਂ ਸਾਨੂੰ ਇਸ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ ਹੋਰ ਤਰੀਕਿਆਂ 'ਤੇ ਵਿਚਾਰ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੱਤੀ ਗਈ, ਸਾਡੀ ਨਜ਼ਰ ਅਪਾਚੇ NIFI ਤਕਨਾਲੋਜੀ 'ਤੇ ਪਈ, ਜੋ ਕਿ ਕੁਝ ਸਰਕਲਾਂ ਵਿੱਚ ਫੈਸ਼ਨਯੋਗ ਹੈ। ਮੈਂ ਤੁਰੰਤ ਕਹਾਂਗਾ ਕਿ ਇਸ ਤਕਨਾਲੋਜੀ ਨੇ ਸਾਨੂੰ ਇਹਨਾਂ 3 ਸੇਵਾਵਾਂ ਨੂੰ ਨੋਟਿਸ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੱਤੀ ਹੈ। ਇਹ ਲੇਖ ਇੱਕ ਫਾਈਲ ਟ੍ਰਾਂਸਪੋਰਟੇਸ਼ਨ ਸੇਵਾ ਦੇ ਵਿਕਾਸ ਅਤੇ ਉਪਭੋਗਤਾ ਲਈ ਇੱਕ ਡੇਟਾ ਟ੍ਰਾਂਸਫਰ ਸੇਵਾ ਦਾ ਵਰਣਨ ਕਰੇਗਾ, ਪਰ ਜੇ ਲੇਖ ਲਾਭਦਾਇਕ ਹੈ, ਤਾਂ ਮੈਂ ਡੇਟਾਬੇਸ ਵਿੱਚ ਡੇਟਾ ਨੂੰ ਅਪਡੇਟ ਕਰਨ ਲਈ ਸੇਵਾ ਬਾਰੇ ਲਿਖਾਂਗਾ.

ਇਹ ਕੀ ਹੈ?

NIFI ਡਾਟਾ ਦੀ ਤੇਜ਼ੀ ਨਾਲ ਸਮਾਨਾਂਤਰ ਲੋਡਿੰਗ ਅਤੇ ਪ੍ਰੋਸੈਸਿੰਗ, ਸਰੋਤਾਂ ਅਤੇ ਪਰਿਵਰਤਨਾਂ ਲਈ ਵੱਡੀ ਗਿਣਤੀ ਵਿੱਚ ਪਲੱਗਇਨ, ਸੰਰਚਨਾਵਾਂ ਦਾ ਸੰਸਕਰਣ ਅਤੇ ਹੋਰ ਬਹੁਤ ਕੁਝ ਲਈ ਇੱਕ ਵੰਡਿਆ ਹੋਇਆ ਆਰਕੀਟੈਕਚਰ ਹੈ। ਇੱਕ ਵਧੀਆ ਬੋਨਸ ਇਹ ਹੈ ਕਿ ਇਸਦਾ ਉਪਯੋਗ ਕਰਨਾ ਬਹੁਤ ਆਸਾਨ ਹੈ. ਮਾਮੂਲੀ ਪ੍ਰਕਿਰਿਆਵਾਂ ਜਿਵੇਂ ਕਿ getFile, sendHttpRequest ਅਤੇ ਹੋਰਾਂ ਨੂੰ ਵਰਗ ਵਜੋਂ ਦਰਸਾਇਆ ਜਾ ਸਕਦਾ ਹੈ। ਹਰੇਕ ਵਰਗ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ, ਜਿਸਦਾ ਪਰਸਪਰ ਪ੍ਰਭਾਵ ਹੇਠਾਂ ਦਿੱਤੇ ਚਿੱਤਰ ਵਿੱਚ ਦੇਖਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਪ੍ਰਕਿਰਿਆ ਸੈਟਅਪ ਇੰਟਰੈਕਸ਼ਨਾਂ 'ਤੇ ਵਧੇਰੇ ਵਿਸਤ੍ਰਿਤ ਦਸਤਾਵੇਜ਼ ਲਿਖੇ ਗਏ ਹਨ ਇੱਥੇ , ਉਹਨਾਂ ਲਈ ਜੋ ਰੂਸੀ ਬੋਲਦੇ ਹਨ - ਇੱਥੇ. ਦਸਤਾਵੇਜ਼ ਪੂਰੀ ਤਰ੍ਹਾਂ ਵਰਣਨ ਕਰਦੇ ਹਨ ਕਿ ਕਿਵੇਂ NIFI ਨੂੰ ਖੋਲ੍ਹਣਾ ਅਤੇ ਚਲਾਉਣਾ ਹੈ, ਨਾਲ ਹੀ ਪ੍ਰਕਿਰਿਆਵਾਂ ਕਿਵੇਂ ਬਣਾਉਣੀਆਂ ਹਨ, ਜਿਸ ਨੂੰ ਵਰਗ ਵੀ ਕਿਹਾ ਜਾਂਦਾ ਹੈ।
ਇੱਕ ਲੇਖ ਲਿਖਣ ਦਾ ਵਿਚਾਰ ਇੱਕ ਲੰਮੀ ਖੋਜ ਅਤੇ ਪ੍ਰਾਪਤ ਜਾਣਕਾਰੀ ਨੂੰ ਕਿਸੇ ਸੁਚੇਤ ਰੂਪ ਵਿੱਚ ਸੰਰਚਨਾ ਕਰਨ ਤੋਂ ਬਾਅਦ ਪੈਦਾ ਹੋਇਆ ਸੀ, ਨਾਲ ਹੀ ਭਵਿੱਖ ਦੇ ਵਿਕਾਸਕਾਰਾਂ ਲਈ ਜੀਵਨ ਨੂੰ ਥੋੜਾ ਆਸਾਨ ਬਣਾਉਣ ਦੀ ਇੱਛਾ..

ਉਦਾਹਰਨ:

ਵਰਗ ਇੱਕ ਦੂਜੇ ਨਾਲ ਕਿਵੇਂ ਪਰਸਪਰ ਕ੍ਰਿਆ ਕਰਦਾ ਹੈ ਇਸਦਾ ਇੱਕ ਉਦਾਹਰਨ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ। ਆਮ ਸਕੀਮ ਕਾਫ਼ੀ ਸਧਾਰਨ ਹੈ: ਸਾਨੂੰ ਇੱਕ HTTP ਬੇਨਤੀ ਪ੍ਰਾਪਤ ਹੁੰਦੀ ਹੈ (ਸਿਧਾਂਤ ਵਿੱਚ, ਬੇਨਤੀ ਦੇ ਮੁੱਖ ਭਾਗ ਵਿੱਚ ਇੱਕ ਫਾਈਲ ਦੇ ਨਾਲ। NIFI ਦੀਆਂ ਸਮਰੱਥਾਵਾਂ ਦਾ ਪ੍ਰਦਰਸ਼ਨ ਕਰਨ ਲਈ, ਇਸ ਉਦਾਹਰਨ ਵਿੱਚ ਬੇਨਤੀ ਸਥਾਨਕ ਫਾਈਲ ਸਟੋਰੇਜ ਤੋਂ ਇੱਕ ਫਾਈਲ ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਪ੍ਰਕਿਰਿਆ ਸ਼ੁਰੂ ਕਰਦੀ ਹੈ। ), ਫਿਰ ਅਸੀਂ ਇੱਕ ਜਵਾਬ ਵਾਪਸ ਭੇਜਦੇ ਹਾਂ ਕਿ ਬੇਨਤੀ ਪ੍ਰਾਪਤ ਕੀਤੀ ਗਈ ਹੈ, FH ਤੋਂ ਇੱਕ ਫਾਈਲ ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਪ੍ਰਕਿਰਿਆ ਅਤੇ ਫਿਰ ਇਸਨੂੰ FTP ਦੁਆਰਾ FH ਵਿੱਚ ਭੇਜਣ ਦੀ ਪ੍ਰਕਿਰਿਆ ਦੇ ਸਮਾਨਾਂਤਰ ਵਿੱਚ। ਇਹ ਸਪੱਸ਼ਟ ਕਰਨ ਯੋਗ ਹੈ ਕਿ ਪ੍ਰਕਿਰਿਆਵਾਂ ਅਖੌਤੀ ਫਲੋਫਾਈਲ ਦੁਆਰਾ ਇੱਕ ਦੂਜੇ ਨਾਲ ਇੰਟਰੈਕਟ ਕਰਦੀਆਂ ਹਨ. ਇਹ NIFI ਵਿੱਚ ਅਧਾਰ ਇਕਾਈ ਹੈ ਜੋ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਅਤੇ ਸਮੱਗਰੀ ਨੂੰ ਸਟੋਰ ਕਰਦੀ ਹੈ। ਸਮੱਗਰੀ ਉਹ ਡੇਟਾ ਹੈ ਜੋ ਸਟ੍ਰੀਮ ਫਾਈਲ ਦੁਆਰਾ ਦਰਸਾਇਆ ਜਾਂਦਾ ਹੈ। ਭਾਵ, ਮੋਟੇ ਤੌਰ 'ਤੇ, ਜੇਕਰ ਤੁਸੀਂ ਇੱਕ ਵਰਗ ਤੋਂ ਇੱਕ ਫਾਈਲ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹੋ ਅਤੇ ਇਸਨੂੰ ਦੂਜੇ ਵਿੱਚ ਟ੍ਰਾਂਸਫਰ ਕਰਦੇ ਹੋ, ਤਾਂ ਸਮੱਗਰੀ ਤੁਹਾਡੀ ਫਾਈਲ ਹੋਵੇਗੀ।

ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ ਦੇਖ ਸਕਦੇ ਹੋ, ਇਹ ਤਸਵੀਰ ਆਮ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ. HandleHttpRequest - ਬੇਨਤੀਆਂ ਨੂੰ ਸਵੀਕਾਰ ਕਰਦਾ ਹੈ, ReplaceText - ਇੱਕ ਜਵਾਬ ਸਰੀਰ ਬਣਾਉਂਦਾ ਹੈ, HandleHttpResponse - ਇੱਕ ਜਵਾਬ ਭੇਜਦਾ ਹੈ। FetchFile - ਇੱਕ ਫਾਈਲ ਸਟੋਰੇਜ ਤੋਂ ਇੱਕ ਫਾਈਲ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ, ਇਸਨੂੰ ਵਰਗ PutSftp ਵਿੱਚ ਟ੍ਰਾਂਸਫਰ ਕਰਦਾ ਹੈ - ਇਸ ਫਾਈਲ ਨੂੰ FTP 'ਤੇ, ਨਿਰਧਾਰਤ ਪਤੇ 'ਤੇ ਰੱਖਦਾ ਹੈ। ਹੁਣ ਇਸ ਪ੍ਰਕਿਰਿਆ ਬਾਰੇ ਹੋਰ.

ਇਸ ਕੇਸ ਵਿੱਚ, ਬੇਨਤੀ ਹਰ ਚੀਜ਼ ਦੀ ਸ਼ੁਰੂਆਤ ਹੈ. ਆਉ ਇਸਦੇ ਸੰਰਚਨਾ ਮਾਪਦੰਡਾਂ ਨੂੰ ਵੇਖੀਏ.

StandardHttpContextMap ਦੇ ਅਪਵਾਦ ਦੇ ਨਾਲ ਇੱਥੇ ਸਭ ਕੁਝ ਮਾਮੂਲੀ ਹੈ - ਇਹ ਇੱਕ ਕਿਸਮ ਦੀ ਸੇਵਾ ਹੈ ਜੋ ਤੁਹਾਨੂੰ ਬੇਨਤੀਆਂ ਭੇਜਣ ਅਤੇ ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ। ਵਧੇਰੇ ਵਿਸਥਾਰ ਵਿੱਚ ਅਤੇ ਇੱਥੋਂ ਤੱਕ ਕਿ ਉਦਾਹਰਣਾਂ ਦੇ ਨਾਲ, ਤੁਸੀਂ ਦੇਖ ਸਕਦੇ ਹੋ - ਇੱਥੇ

ਅੱਗੇ, ਆਉ ਵਰਗ ਦੇ ReplaceText ਕੌਂਫਿਗਰੇਸ਼ਨ ਪੈਰਾਮੀਟਰਾਂ ਨੂੰ ਵੇਖੀਏ। ਇਹ ReplacementValue ਵੱਲ ਧਿਆਨ ਦੇਣ ਯੋਗ ਹੈ - ਇਹ ਉਹ ਹੈ ਜੋ ਉਪਭੋਗਤਾ ਨੂੰ ਜਵਾਬ ਦੇ ਰੂਪ ਵਿੱਚ ਵਾਪਸ ਕੀਤਾ ਜਾਵੇਗਾ. ਸੈਟਿੰਗਾਂ ਵਿੱਚ ਤੁਸੀਂ ਲੌਗਿੰਗ ਦੇ ਪੱਧਰ ਨੂੰ ਵਿਵਸਥਿਤ ਕਰ ਸਕਦੇ ਹੋ, ਤੁਸੀਂ ਲੌਗ ਦੇਖ ਸਕਦੇ ਹੋ {ਜਿੱਥੇ ਤੁਸੀਂ nifi-1.9.2/logs ਨੂੰ ਅਨਪੈਕ ਕੀਤਾ ਹੈ, ਉੱਥੇ ਅਸਫਲਤਾ/ਸਫਲਤਾ ਮਾਪਦੰਡ ਵੀ ਹਨ - ਇਹਨਾਂ ਪੈਰਾਮੀਟਰਾਂ ਦੇ ਆਧਾਰ 'ਤੇ ਤੁਸੀਂ ਪੂਰੀ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਨਿਯੰਤ੍ਰਿਤ ਕਰ ਸਕਦੇ ਹੋ। . ਭਾਵ, ਸਫਲ ਟੈਕਸਟ ਪ੍ਰੋਸੈਸਿੰਗ ਦੇ ਮਾਮਲੇ ਵਿੱਚ, ਉਪਭੋਗਤਾ ਨੂੰ ਜਵਾਬ ਭੇਜਣ ਦੀ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਬੁਲਾਇਆ ਜਾਵੇਗਾ, ਅਤੇ ਇੱਕ ਹੋਰ ਮਾਮਲੇ ਵਿੱਚ ਅਸੀਂ ਅਸਫਲ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਲੌਗ ਕਰਾਂਗੇ.

HandleHttpResponse ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਵਿੱਚ ਸਥਿਤੀ ਨੂੰ ਛੱਡ ਕੇ ਕੁਝ ਖਾਸ ਦਿਲਚਸਪ ਨਹੀਂ ਹੈ ਜਦੋਂ ਇੱਕ ਜਵਾਬ ਸਫਲਤਾਪੂਰਵਕ ਬਣਾਇਆ ਜਾਂਦਾ ਹੈ।

ਅਸੀਂ ਬੇਨਤੀ ਅਤੇ ਜਵਾਬ ਨੂੰ ਸੁਲਝਾ ਲਿਆ ਹੈ - ਆਓ ਫਾਈਲ ਪ੍ਰਾਪਤ ਕਰਨ ਅਤੇ ਇਸਨੂੰ FTP ਸਰਵਰ 'ਤੇ ਰੱਖਣ ਲਈ ਅੱਗੇ ਵਧੀਏ। FetchFile - ਸੈਟਿੰਗਾਂ ਵਿੱਚ ਦਰਸਾਏ ਮਾਰਗ 'ਤੇ ਇੱਕ ਫਾਈਲ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ ਅਤੇ ਇਸਨੂੰ ਅਗਲੀ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਭੇਜਦਾ ਹੈ।

ਅਤੇ ਫਿਰ PutSftp ਵਰਗ - ਫਾਈਲ ਨੂੰ ਫਾਈਲ ਸਟੋਰੇਜ ਵਿੱਚ ਰੱਖਦਾ ਹੈ। ਅਸੀਂ ਹੇਠਾਂ ਸੰਰਚਨਾ ਪੈਰਾਮੀਟਰ ਦੇਖ ਸਕਦੇ ਹਾਂ।

ਇਹ ਇਸ ਤੱਥ ਵੱਲ ਧਿਆਨ ਦੇਣ ਯੋਗ ਹੈ ਕਿ ਹਰੇਕ ਵਰਗ ਇੱਕ ਵੱਖਰੀ ਪ੍ਰਕਿਰਿਆ ਹੈ ਜੋ ਸ਼ੁਰੂ ਕੀਤੀ ਜਾਣੀ ਚਾਹੀਦੀ ਹੈ. ਅਸੀਂ ਸਭ ਤੋਂ ਸਰਲ ਉਦਾਹਰਣ ਨੂੰ ਦੇਖਿਆ ਜਿਸ ਲਈ ਕਿਸੇ ਗੁੰਝਲਦਾਰ ਅਨੁਕੂਲਤਾ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ। ਅੱਗੇ, ਅਸੀਂ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਥੋੜਾ ਹੋਰ ਗੁੰਝਲਦਾਰ ਦੇਖਾਂਗੇ, ਜਿੱਥੇ ਅਸੀਂ ਖੋਖਿਆਂ 'ਤੇ ਥੋੜਾ ਜਿਹਾ ਲਿਖਾਂਗੇ।

ਹੋਰ ਗੁੰਝਲਦਾਰ ਉਦਾਹਰਨ

SOAP ਸੰਦੇਸ਼ ਨੂੰ ਸੋਧਣ ਦੀ ਪ੍ਰਕਿਰਿਆ ਦੇ ਕਾਰਨ ਖਪਤਕਾਰਾਂ ਨੂੰ ਡੇਟਾ ਟ੍ਰਾਂਸਫਰ ਸੇਵਾ ਥੋੜੀ ਹੋਰ ਗੁੰਝਲਦਾਰ ਸਾਬਤ ਹੋਈ. ਆਮ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਹੇਠਾਂ ਦਿੱਤੇ ਚਿੱਤਰ ਵਿੱਚ ਦਿਖਾਇਆ ਗਿਆ ਹੈ.

ਇੱਥੇ ਇਹ ਵਿਚਾਰ ਵੀ ਖਾਸ ਤੌਰ 'ਤੇ ਗੁੰਝਲਦਾਰ ਨਹੀਂ ਹੈ: ਸਾਨੂੰ ਉਪਭੋਗਤਾ ਤੋਂ ਇੱਕ ਬੇਨਤੀ ਪ੍ਰਾਪਤ ਹੋਈ ਹੈ ਕਿ ਉਸਨੂੰ ਡੇਟਾ ਦੀ ਲੋੜ ਹੈ, ਇੱਕ ਜਵਾਬ ਭੇਜਿਆ ਹੈ ਕਿ ਉਸਨੂੰ ਇੱਕ ਸੁਨੇਹਾ ਮਿਲਿਆ ਹੈ, ਜਵਾਬ ਫਾਈਲ ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਪ੍ਰਕਿਰਿਆ ਸ਼ੁਰੂ ਕੀਤੀ, ਫਿਰ ਇਸਨੂੰ ਇੱਕ ਖਾਸ ਤਰਕ ਨਾਲ ਸੰਪਾਦਿਤ ਕੀਤਾ, ਅਤੇ ਫਿਰ ਨੇ ਸਰਵਰ ਨੂੰ ਇੱਕ SOAP ਸੰਦੇਸ਼ ਦੇ ਰੂਪ ਵਿੱਚ ਉਪਭੋਗਤਾ ਨੂੰ ਫਾਈਲ ਟ੍ਰਾਂਸਫਰ ਕੀਤੀ।

ਮੈਨੂੰ ਲਗਦਾ ਹੈ ਕਿ ਉਹਨਾਂ ਵਰਗਾਂ ਦਾ ਦੁਬਾਰਾ ਵਰਣਨ ਕਰਨ ਦੀ ਕੋਈ ਲੋੜ ਨਹੀਂ ਹੈ ਜੋ ਅਸੀਂ ਉੱਪਰ ਵੇਖੇ ਹਨ - ਆਓ ਸਿੱਧੇ ਨਵੇਂ ਵੱਲ ਚਲੀਏ। ਜੇਕਰ ਤੁਹਾਨੂੰ ਕਿਸੇ ਵੀ ਫਾਈਲ ਨੂੰ ਸੰਪਾਦਿਤ ਕਰਨ ਦੀ ਲੋੜ ਹੈ ਅਤੇ ਸਧਾਰਨ ਰੀਪਲੇਸ ਟੈਕਸਟ ਕਿਸਮ ਦੇ ਵਰਗ ਢੁਕਵੇਂ ਨਹੀਂ ਹਨ, ਤਾਂ ਤੁਹਾਨੂੰ ਆਪਣੀ ਸਕ੍ਰਿਪਟ ਲਿਖਣੀ ਪਵੇਗੀ। ਇਹ ExecuteGroogyScript ਵਰਗ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਇਸ ਦੀਆਂ ਸੈਟਿੰਗਾਂ ਹੇਠਾਂ ਦਿੱਤੀਆਂ ਗਈਆਂ ਹਨ।

ਇਸ ਵਰਗ ਵਿੱਚ ਸਕ੍ਰਿਪਟ ਲੋਡ ਕਰਨ ਲਈ ਦੋ ਵਿਕਲਪ ਹਨ। ਪਹਿਲੀ ਇੱਕ ਸਕ੍ਰਿਪਟ ਦੇ ਨਾਲ ਇੱਕ ਫਾਈਲ ਨੂੰ ਡਾਊਨਲੋਡ ਕਰਕੇ ਹੈ. ਦੂਜਾ ਸਕ੍ਰਿਪਟ ਬਾਡੀ ਵਿੱਚ ਇੱਕ ਸਕ੍ਰਿਪਟ ਪਾ ਕੇ ਹੈ। ਜਿੱਥੋਂ ਤੱਕ ਮੈਨੂੰ ਪਤਾ ਹੈ, executeScript ਵਰਗ ਕਈ ਭਾਸ਼ਾਵਾਂ ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ - ਉਹਨਾਂ ਵਿੱਚੋਂ ਇੱਕ ਗਰੂਵੀ ਹੈ। ਮੈਂ ਜਾਵਾ ਡਿਵੈਲਪਰਾਂ ਨੂੰ ਨਿਰਾਸ਼ ਕਰਾਂਗਾ - ਤੁਸੀਂ ਅਜਿਹੇ ਵਰਗਾਂ ਵਿੱਚ ਜਾਵਾ ਵਿੱਚ ਸਕ੍ਰਿਪਟਾਂ ਨਹੀਂ ਲਿਖ ਸਕਦੇ. ਉਹਨਾਂ ਲਈ ਜੋ ਅਸਲ ਵਿੱਚ ਚਾਹੁੰਦੇ ਹਨ, ਤੁਹਾਨੂੰ ਆਪਣਾ ਖੁਦ ਦਾ ਕਸਟਮ ਵਰਗ ਬਣਾਉਣ ਅਤੇ ਇਸਨੂੰ NIFI ਸਿਸਟਮ ਵਿੱਚ ਜੋੜਨ ਦੀ ਲੋੜ ਹੈ। ਇਹ ਸਾਰਾ ਓਪਰੇਸ਼ਨ ਇੱਕ ਡਫਲੀ ਦੇ ਨਾਲ ਕਾਫ਼ੀ ਲੰਬਾ ਨਾਚ ਦੇ ਨਾਲ ਹੈ, ਜਿਸ ਨਾਲ ਅਸੀਂ ਇਸ ਲੇਖ ਵਿੱਚ ਨਹੀਂ ਵਿਚਾਰਾਂਗੇ. ਮੈਂ ਗਰੋਵੀ ਭਾਸ਼ਾ ਚੁਣੀ। ਹੇਠਾਂ ਇੱਕ ਟੈਸਟ ਸਕ੍ਰਿਪਟ ਹੈ ਜੋ ਇੱਕ SOAP ਸੁਨੇਹੇ ਵਿੱਚ ਆਈਡੀ ਨੂੰ ਲਗਾਤਾਰ ਅੱਪਡੇਟ ਕਰਦੀ ਹੈ। ਇਹ ਨੋਟ ਕਰਨਾ ਮਹੱਤਵਪੂਰਨ ਹੈ. ਤੁਸੀਂ flowFile ਤੋਂ ਫਾਈਲ ਲੈਂਦੇ ਹੋ ਅਤੇ ਇਸਨੂੰ ਅਪਡੇਟ ਕਰਦੇ ਹੋ, ਇਹ ਨਾ ਭੁੱਲੋ ਕਿ ਤੁਹਾਨੂੰ ਇਸਨੂੰ ਉੱਥੇ ਵਾਪਸ ਰੱਖਣ ਦੀ ਜ਼ਰੂਰਤ ਹੈ, ਅਪਡੇਟ ਕੀਤਾ ਗਿਆ ਹੈ. ਇਹ ਵੀ ਧਿਆਨ ਦੇਣ ਯੋਗ ਹੈ ਕਿ ਸਾਰੀਆਂ ਲਾਇਬ੍ਰੇਰੀਆਂ ਸ਼ਾਮਲ ਨਹੀਂ ਹਨ। ਇਹ ਹੋ ਸਕਦਾ ਹੈ ਕਿ ਤੁਹਾਨੂੰ ਅਜੇ ਵੀ ਇੱਕ libs ਨੂੰ ਆਯਾਤ ਕਰਨਾ ਪਏਗਾ। ਇੱਕ ਹੋਰ ਨਨੁਕਸਾਨ ਇਹ ਹੈ ਕਿ ਇਸ ਵਰਗ ਵਿੱਚ ਸਕ੍ਰਿਪਟ ਨੂੰ ਡੀਬੱਗ ਕਰਨਾ ਕਾਫ਼ੀ ਮੁਸ਼ਕਲ ਹੈ। 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 ਸੁਨੇਹਾ ਪ੍ਰਸਾਰਿਤ ਕੀਤਾ ਜਾਵੇਗਾ। ਅਸੀਂ ਕਿੱਥੇ ਲਿਖਦੇ ਹਾਂ। ਅੱਗੇ ਤੁਹਾਨੂੰ ਇਹ ਦਰਸਾਉਣ ਦੀ ਲੋੜ ਹੈ ਕਿ ਇਹ SOAP ਹੈ।

ਕਈ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਸ਼ਾਮਲ ਕਰੋ ਜਿਵੇਂ ਕਿ ਹੋਸਟ ਅਤੇ ਐਕਸ਼ਨ (ਸੋਪ ਐਕਸ਼ਨ)। ਅਸੀਂ ਸੰਭਾਲਦੇ ਹਾਂ ਅਤੇ ਜਾਂਚ ਕਰਦੇ ਹਾਂ। ਤੁਸੀਂ ਇਸ ਬਾਰੇ ਹੋਰ ਵੇਰਵੇ ਦੇਖ ਸਕਦੇ ਹੋ ਕਿ SOAP ਬੇਨਤੀਆਂ ਕਿਵੇਂ ਭੇਜਣੀਆਂ ਹਨ ਇੱਥੇ

ਅਸੀਂ NIFI ਪ੍ਰਕਿਰਿਆਵਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਲਈ ਕਈ ਵਿਕਲਪਾਂ ਨੂੰ ਦੇਖਿਆ। ਉਹ ਕਿਵੇਂ ਗੱਲਬਾਤ ਕਰਦੇ ਹਨ ਅਤੇ ਉਨ੍ਹਾਂ ਦਾ ਅਸਲ ਲਾਭ ਕੀ ਹੈ? ਵਿਚਾਰੀਆਂ ਗਈਆਂ ਉਦਾਹਰਣਾਂ ਟੈਸਟ ਵਾਲੀਆਂ ਹਨ ਅਤੇ ਅਸਲ ਵਿੱਚ ਲੜਾਈ ਵਿੱਚ ਵਾਪਰਨ ਵਾਲੀਆਂ ਉਦਾਹਰਣਾਂ ਨਾਲੋਂ ਥੋੜ੍ਹੀਆਂ ਵੱਖਰੀਆਂ ਹਨ। ਮੈਨੂੰ ਉਮੀਦ ਹੈ ਕਿ ਇਹ ਲੇਖ ਡਿਵੈਲਪਰਾਂ ਲਈ ਥੋੜਾ ਲਾਭਦਾਇਕ ਹੋਵੇਗਾ. ਤੁਹਾਡੇ ਧਿਆਨ ਲਈ ਧੰਨਵਾਦ. ਜੇ ਤੁਹਾਡੇ ਕੋਈ ਸਵਾਲ ਹਨ, ਤਾਂ ਲਿਖੋ। ਮੈਂ ਜਵਾਬ ਦੇਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਾਂਗਾ।

ਸਰੋਤ: www.habr.com