ਕਾਇਨੇਸਿਸ ਸਟ੍ਰੀਮ ਵਿੱਚ ਰਿਕਾਰਡ ਜੋੜਦੇ ਸਮੇਂ AWS Lambda ਟਾਈਮਆਊਟ ਮੁੱਦਿਆਂ ਨੂੰ ਠੀਕ ਕਰਨਾ

Kinesis ਡਾਟਾ ਸਟ੍ਰੀਮਜ਼ ਲਈ AWS Lambda ਟਾਈਮਆਉਟ ਦਾ ਨਿਪਟਾਰਾ ਕਰਨਾ

ਕਲਪਨਾ ਕਰੋ ਕਿ ਤੁਸੀਂ AWS 'ਤੇ ਇੱਕ ਰੀਅਲ-ਟਾਈਮ ਡਾਟਾ ਪਾਈਪਲਾਈਨ ਬਣਾ ਰਹੇ ਹੋ, ਇੱਕ ਸੈੱਟਅੱਪ ਦੇ ਨਾਲ ਜੋ SQS ਤੋਂ ਲੈਂਬਡਾ ਫੰਕਸ਼ਨ ਅਤੇ ਅੰਤ ਵਿੱਚ ਇੱਕ Kinesis ਡਾਟਾ ਸਟ੍ਰੀਮ ਵਿੱਚ ਸੰਦੇਸ਼ ਭੇਜਦਾ ਹੈ। 📨 ਇਹ ਪ੍ਰਵਾਹ ਸਿਧਾਂਤ ਵਿੱਚ ਸਹਿਜੇ ਹੀ ਕੰਮ ਕਰਦਾ ਹੈ, ਪਰ ਕਈ ਵਾਰ ਹਕੀਕਤ ਵਿੱਚ ਹੋਰ ਯੋਜਨਾਵਾਂ ਹੁੰਦੀਆਂ ਹਨ। ਜਦੋਂ ਤੁਸੀਂ ਆਰਾਮ ਕਰਨ ਜਾ ਰਹੇ ਹੋ, ਤਾਂ ਤੁਹਾਡੇ ਲਾਂਬਡਾ ਫੰਕਸ਼ਨ ਲੌਗਸ ਵਿੱਚ ਇੱਕ ETIMEDOUT ਗਲਤੀ ਆ ਜਾਂਦੀ ਹੈ।

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

ਇਸ ਤਰ੍ਹਾਂ ਦੀਆਂ ਸਥਿਤੀਆਂ ਵਿੱਚ, ਬਹੁਤ ਸਾਰੇ ਡਿਵੈਲਪਰਾਂ ਨੂੰ "Runtime.UnhandledPromiseRejection" ਅਤੇ "ERR_HTTP2_STREAM_CANCEL" ਵਰਗੇ ਗੁਪਤ ਸੰਦੇਸ਼ਾਂ ਦੁਆਰਾ ਸਟੰਪ ਕੀਤਾ ਗਿਆ ਹੈ। ਰੋਡ ਬਲਾਕ.

ਇੱਥੇ, ਅਸੀਂ ਇਹ ਦੇਖਾਂਗੇ ਕਿ ਇਹ ਸਮਾਂ ਸਮਾਪਤੀ ਦਾ ਕਾਰਨ ਕੀ ਹੈ, ਉਹਨਾਂ ਨੂੰ ਸੰਭਾਲਣ ਦੇ ਵਿਹਾਰਕ ਤਰੀਕੇ, ਅਤੇ ਤੁਹਾਡੀ AWS ਸੰਰਚਨਾ ਵਿੱਚ ਸਮਾਯੋਜਨ ਜੋ ਤੁਹਾਡੀ ਸਟ੍ਰੀਮ ਨੂੰ ਸਥਿਰ ਕਰਨ ਦੀ ਕੁੰਜੀ ਹੋ ਸਕਦੇ ਹਨ। 🛠️ ਅੰਤ ਤੱਕ, ਤੁਹਾਨੂੰ ਪਤਾ ਹੋਵੇਗਾ ਕਿ ETIMEDOUT ਤਰੁੱਟੀਆਂ ਦਾ ਨਿਪਟਾਰਾ ਅਤੇ ਹੱਲ ਕਿਵੇਂ ਕਰਨਾ ਹੈ ਅਤੇ ਤੁਹਾਡੇ ਲਾਂਬਡਾ ਅਤੇ ਕਾਇਨੇਸਿਸ ਦੇ ਪ੍ਰਵਾਹ ਨੂੰ ਸੁਚਾਰੂ ਢੰਗ ਨਾਲ ਚਲਾਉਣਾ ਹੈ।

Kinesis ਸਟ੍ਰੀਮ ਨਾਲ AWS Lambda ਭਰੋਸੇਯੋਗਤਾ ਨੂੰ ਵਧਾਉਣਾ

ਪ੍ਰਦਾਨ ਕੀਤੀਆਂ JavaScript ਸਕ੍ਰਿਪਟਾਂ ਨੂੰ ਇੱਕ ਕੁਸ਼ਲ AWS Lambda ਫੰਕਸ਼ਨ ਬਣਾਉਣ ਲਈ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਹੈ ਜੋ ਇੱਕ SQS ਕਤਾਰ ਤੋਂ ਸੁਨੇਹਿਆਂ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ ਅਤੇ ਫਿਰ ਉਹਨਾਂ ਨੂੰ ਇੱਕ Amazon Kinesis ਡਾਟਾ ਸਟ੍ਰੀਮ ਵਿੱਚ ਪ੍ਰਕਾਸ਼ਿਤ ਕਰਦਾ ਹੈ। ਇਸ ਹੱਲ ਦਾ ਮੂਲ ਲਾਂਬਡਾ ਫੰਕਸ਼ਨ ਦੀ ਕਨੈਕਟੀਵਿਟੀ ਮੁੱਦਿਆਂ ਨੂੰ ਸੰਬੋਧਿਤ ਕਰਦੇ ਹੋਏ ਅਸਿੰਕਰੋਨਸ ਤੌਰ 'ਤੇ ਸੁਨੇਹਿਆਂ ਨੂੰ ਸੰਭਾਲਣ ਦੀ ਯੋਗਤਾ ਵਿੱਚ ਹੈ ਜਿਸਦਾ ਨਤੀਜਾ ਅਕਸਰ ਹੁੰਦਾ ਹੈ ETIMEDOUT ਗਲਤੀਆਂ ਸਕ੍ਰਿਪਟ ਦਾ ਇੱਕ ਮੁੱਖ ਹਿੱਸਾ ਦੀ ਸ਼ੁਰੂਆਤ ਹੈ KinesisClient, ਜੋ ਕਿ ਖੇਤਰ, ਮੁੜ-ਕੋਸ਼ਿਸ਼ ਗਿਣਤੀ, ਅਤੇ ਕੁਨੈਕਸ਼ਨ ਸਮਾਂ ਸਮਾਪਤ ਵਰਗੀਆਂ ਜ਼ਰੂਰੀ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਕੌਂਫਿਗਰ ਕਰਦਾ ਹੈ। ਇਹ ਸੰਰਚਨਾ ਕਲਾਉਡ ਸੈੱਟਅੱਪ ਵਿੱਚ ਮਹੱਤਵਪੂਰਨ ਹਨ, ਕਿਉਂਕਿ ਉਹ ਐਪਲੀਕੇਸ਼ਨ ਦੀ ਜਵਾਬਦੇਹੀ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਦੇ ਹਨ ਅਤੇ ਸਮਾਂ ਸਮਾਪਤ ਹੋਣ ਤੋਂ ਪਹਿਲਾਂ ਇਹ ਕਿੰਨੀ ਦੇਰ ਤੱਕ ਜੁੜਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੇਗਾ। ਉੱਚਾ ਸੈੱਟ ਕਰਕੇ connectTimeout ਜਾਂ ਮੁੜ-ਕੋਸ਼ਿਸ਼ ਕਰਨ ਦੀਆਂ ਕੋਸ਼ਿਸ਼ਾਂ ਨੂੰ ਐਡਜਸਟ ਕਰਨਾ, ਅਸੀਂ ਫੰਕਸ਼ਨ ਨੂੰ ਨੈੱਟਵਰਕ ਦੇਰੀ ਨੂੰ ਵਧੇਰੇ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਸੰਭਾਲਣ ਵਿੱਚ ਮਦਦ ਕਰ ਸਕਦੇ ਹਾਂ।

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

ਦ ਪ੍ਰਕਿਰਿਆ ਈਵੈਂਟ ਸਕ੍ਰਿਪਟ ਦੇ ਅੰਦਰ ਫੰਕਸ਼ਨ ਮਾਡਯੂਲਰ ਹੈ ਅਤੇ ਮੁੱਖ ਡੇਟਾ ਪਰਿਵਰਤਨ ਅਤੇ ਭੇਜਣ ਦੀ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਹੈਂਡਲ ਕਰਦਾ ਹੈ। ਇਹ ਫੰਕਸ਼ਨ SQS ਸੰਦੇਸ਼ ਵਿੱਚ ਲੈਂਦਾ ਹੈ, ਇਸਨੂੰ ਪਾਰਸ ਕਰਦਾ ਹੈ, ਅਤੇ ਇਸਨੂੰ ਬਾਈਟ ਫਾਰਮੈਟ ਵਿੱਚ ਏਨਕੋਡ ਕਰਦਾ ਹੈ ਜਿਸਦੀ ਕਿਨੇਸਿਸ ਨੂੰ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਇੱਥੇ, ਦ TextEncoder().encode() ਵਿਧੀ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿਉਂਕਿ ਕਾਇਨੇਸਿਸ ਸਿਰਫ ਬਾਈਨਰੀ ਡੇਟਾ ਨੂੰ ਸਵੀਕਾਰ ਕਰਦਾ ਹੈ; JSON ਨੂੰ ਇੱਕ ਅਨੁਕੂਲ ਫਾਰਮੈਟ ਵਿੱਚ ਬਦਲਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਫੰਕਸ਼ਨ ਦਾ ਇਹ ਹਿੱਸਾ ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ ਕਿ ਲਾਂਬਡਾ ਸਹੀ ਢੰਗ ਨਾਲ ਡੇਟਾ ਭੇਜਦਾ ਹੈ, ਬੇਮੇਲ ਡੇਟਾ ਫਾਰਮੈਟਾਂ ਤੋਂ ਹੋਣ ਵਾਲੀਆਂ ਗਲਤੀਆਂ ਦੀ ਸੰਭਾਵਨਾ ਨੂੰ ਘਟਾਉਂਦਾ ਹੈ। ਫੰਕਸ਼ਨ ਇੱਕ ਕਸਟਮ ਭਾਗ ਕੁੰਜੀ ਜਨਰੇਟਰ ਫੰਕਸ਼ਨ ਦੀ ਵੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਜੋ ਕਿਨੇਸਿਸ ਸਟ੍ਰੀਮ ਦੇ ਸ਼ਾਰਡਾਂ ਵਿੱਚ ਰਿਕਾਰਡਾਂ ਨੂੰ ਵੰਡਦਾ ਹੈ। ਡਾਇਨਾਮਿਕ ਪਾਰਟੀਸ਼ਨ ਕੁੰਜੀਆਂ (ਜਿਵੇਂ ਕਿ ਬੇਤਰਤੀਬ ਕੁੰਜੀਆਂ) ਦੀ ਵਰਤੋਂ ਕਰਕੇ, ਸਕ੍ਰਿਪਟ ਇੱਕੋ ਸ਼ਾਰਡ ਨੂੰ ਵਾਰ-ਵਾਰ ਦਬਾਉਣ ਦੀ ਸੰਭਾਵਨਾ ਨੂੰ ਘਟਾਉਂਦੀ ਹੈ, ਜੋ "ਹੌਟ ਸ਼ਾਰਡਜ਼" ਨੂੰ ਰੋਕ ਸਕਦੀ ਹੈ ਜੋ ਰੁਕਾਵਟਾਂ ਵੱਲ ਲੈ ਜਾਂਦੇ ਹਨ।

ਅੰਤ ਵਿੱਚ, ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਕਿ ਇਹ ਸੈੱਟਅੱਪ ਵੱਖ-ਵੱਖ ਸਥਿਤੀਆਂ ਵਿੱਚ ਸਹੀ ਢੰਗ ਨਾਲ ਕੰਮ ਕਰਦਾ ਹੈ, ਸਕ੍ਰਿਪਟਾਂ ਨੂੰ ਸ਼ਾਮਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਯੂਨਿਟ ਟੈਸਟ ਜੇਸਟ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ. ਯੂਨਿਟ ਟੈਸਟ ਲਾਈਵ AWS ਸਰੋਤਾਂ ਦੀ ਲੋੜ ਤੋਂ ਬਿਨਾਂ ਕਾਇਨੇਸਿਸ ਕਲਾਇੰਟ ਦੇ ਵਿਵਹਾਰ ਦੀ ਨਕਲ ਕਰਨਾ ਸੰਭਵ ਬਣਾਉਂਦੇ ਹਨ, ਇੱਕ ਨਿਯੰਤਰਿਤ ਵਾਤਾਵਰਣ ਵਿੱਚ ਟਾਈਮਆਉਟ ਜਾਂ ਡੇਟਾ ਪਰਿਵਰਤਨ ਮੁੱਦਿਆਂ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਲਾਂਬਡਾ ਦੀ ਯੋਗਤਾ ਦੀ ਜਾਂਚ ਕਰਨ ਦਾ ਇੱਕ ਭਰੋਸੇਯੋਗ ਤਰੀਕਾ ਪੇਸ਼ ਕਰਦੇ ਹਨ। ਉਦਾਹਰਨ ਲਈ, ਜੇ ਕਿਨੇਸਿਸ ਕਲਾਇੰਟ ਕਨੈਕਟ ਕਰਨ ਵਿੱਚ ਅਸਮਰੱਥ ਹੈ, ਜੇਸਟ ਮੌਕਸ ਇੱਕ ਸਮਾਂ ਸਮਾਪਤੀ ਗਲਤੀ ਦੀ ਨਕਲ ਕਰ ਸਕਦੇ ਹਨ, ਇਹ ਪੁਸ਼ਟੀ ਕਰਦੇ ਹੋਏ ਕਿ ਗਲਤੀ ਦੇ ਅੰਦਰ ਹੈਂਡਲਿੰਗ ਪ੍ਰਕਿਰਿਆ ਈਵੈਂਟ ਇਰਾਦੇ ਅਨੁਸਾਰ ਕੰਮ ਕਰਦਾ ਹੈ। ਇਹ ਰਣਨੀਤੀ ਮਜਬੂਤ ਪ੍ਰਮਾਣਿਕਤਾ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ, ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਦੀ ਹੈ ਕਿ ਲਾਂਬਡਾ ਕਈ ਨੈਟਵਰਕ ਸਥਿਤੀਆਂ ਵਿੱਚ ਭਰੋਸੇਯੋਗ ਹੈ। 🧪 ਇਹਨਾਂ ਤੱਤਾਂ ਨੂੰ ਮਿਲਾ ਕੇ, Lambda ਫੰਕਸ਼ਨ SQS ਤੋਂ Kinesis ਤੱਕ ਡਾਟਾ ਨੂੰ ਕੁਸ਼ਲਤਾ ਨਾਲ ਸੰਭਾਲ ਸਕਦਾ ਹੈ ਜਦੋਂ ਕਿ ਸਮਾਂ ਸਮਾਪਤੀ ਅਤੇ ਹੋਰ ਆਮ ਸਟ੍ਰੀਮਿੰਗ ਗਲਤੀਆਂ ਨੂੰ ਘੱਟ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।

import { KinesisClient, PutRecordCommand } from "@aws-sdk/client-kinesis";
const KINESIS_CLIENT = new KinesisClient({
  region: 'us-west-2',
  maxRetries: 3,
  requestHandler: {
    connectionTimeout: 5000, // Lower timeout for quicker retries
  },
});
export const handler = async (event) => {
  const promises = event.Records.map(record => processEvent(record.body));
  const results = await Promise.allSettled(promises);
  results.forEach(result => {
    if (result.status !== "fulfilled") {
      console.error("Failed:", result.reason);
    }
  });
};
async function processEvent(body) {
  const data = JSON.parse(body);
  const partitionKey = generatePartitionKey(data);
  const encodedData = new TextEncoder().encode(JSON.stringify(data));
  try {
    await KINESIS_CLIENT.send(new PutRecordCommand({
      Data: encodedData,
      StreamName: 'InputEventStream',
      PartitionKey: partitionKey
    }));
  } catch (error) {
    console.error("Error putting record:", error);
    throw error;
  }
}
function generatePartitionKey(data) {
  return data.userId ? data.userId.toString() : Date.now().toString();
}

import { KinesisClient, PutRecordCommand } from "@aws-sdk/client-kinesis";
const KINESIS_CLIENT = new KinesisClient({
  region: 'us-west-2',
  maxRetries: 5,
  httpOptions: {
    connectTimeout: 15000, // Extended timeout
    timeout: 20000 // Total request timeout
  }
});
export const handler = async (event) => {
  const results = await Promise.allSettled(event.Records.map(async (record) => {
    await processEvent(record.body);
  }));
  results.forEach((result) => {
    if (result.status !== "fulfilled") {
      console.log("Unsuccessful attempt:", result.reason);
    }
  });
};
async function processEvent(body) {
  const parsedData = JSON.parse(body);
  const partitionKey = `pk-${Math.random()}`;
  try {
    await KINESIS_CLIENT.send(new PutRecordCommand({
      StreamName: "InputEventStream",
      Data: new TextEncoder().encode(JSON.stringify(parsedData)),
      PartitionKey: partitionKey
    }));
  } catch (err) {
    if (err.name === "TimeoutError") {
      console.warn("Retry on timeout:", err);
    }
    throw err;
  }
}

import { handler, processEvent } from './your-lambda-file.js';
import { KinesisClient } from "@aws-sdk/client-kinesis";
jest.mock("@aws-sdk/client-kinesis");
describe('Lambda Handler and Kinesis Integration', () => {
  it('should call processEvent for each record in the event', async () => {
    const mockEvent = {
      Records: [{ body: '{"userId": 1, "data": "test"}' }]
    };
    await handler(mockEvent);
    expect(KinesisClient.prototype.send).toHaveBeenCalledTimes(1);
  });
  it('should handle timeout errors gracefully', async () => {
    KinesisClient.prototype.send.mockRejectedValueOnce(new Error('TimeoutError'));
    await expect(processEvent('{"userId": 2}')).rejects.toThrow('TimeoutError');
  });
});

AWS Lambda-Kinesis ਏਕੀਕਰਣ ਵਿੱਚ ਸਮਾਂ ਸਮਾਪਤੀ ਦੀਆਂ ਗਲਤੀਆਂ ਨੂੰ ਸਮਝਣਾ

ਟਾਈਮਆਉਟ ਗਲਤੀਆਂ ਜਿਵੇਂ ਕਿ ETIMEDOUT AWS Lambda ਫੰਕਸ਼ਨ ਵਿੱਚ ਅਕਸਰ ਨਿਰਾਸ਼ਾਜਨਕ ਹੋ ਸਕਦਾ ਹੈ, ਖਾਸ ਤੌਰ 'ਤੇ ਐਮਾਜ਼ਾਨ ਕਾਇਨੇਸਿਸ ਨਾਲ ਡਾਟਾ ਸਟ੍ਰੀਮਿੰਗ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨ ਵਾਲੇ ਏਕੀਕਰਣਾਂ ਵਿੱਚ। ਜ਼ਿਆਦਾਤਰ ਮਾਮਲਿਆਂ ਵਿੱਚ, ਇਹ ਤਰੁੱਟੀਆਂ ਲਾਂਬਡਾ ਫੰਕਸ਼ਨ ਦੇ ਨੈਟਵਰਕ ਕਨੈਕਸ਼ਨ ਸਮਾਂ ਸੀਮਾ ਤੋਂ ਵੱਧ ਹੋਣ ਕਾਰਨ ਵਾਪਰਦੀਆਂ ਹਨ, ਖਾਸ ਤੌਰ 'ਤੇ ਇੱਕ ਦੌਰਾਨ KinesisClient ਬੇਨਤੀ ਲਾਂਬਡਾ ਵਿੱਚ ਡਿਫੌਲਟ ਸੈਟਿੰਗਾਂ ਹਮੇਸ਼ਾ ਇਸ ਕਿਸਮ ਦੀਆਂ ਨੈਟਵਰਕ ਬੇਨਤੀਆਂ ਨੂੰ ਅਨੁਕੂਲ ਨਹੀਂ ਕਰ ਸਕਦੀਆਂ, ਖਾਸ ਕਰਕੇ ਜਦੋਂ ਉੱਚ-ਥਰੂਪੁੱਟ ਸਟ੍ਰੀਮ ਜਾਂ ਵੱਡੀ ਮਾਤਰਾ ਵਿੱਚ ਡੇਟਾ ਨਾਲ ਨਜਿੱਠਣ ਵੇਲੇ। ਉਦਾਹਰਨ ਲਈ, ਐਡਜਸਟ ਕਰਨਾ connectTimeout ਜਾਂ maxRetries ਸੰਰਚਨਾਵਾਂ ਇਸ ਮੁੱਦੇ ਨੂੰ ਘੱਟ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰ ਸਕਦੀਆਂ ਹਨ, ਜਿਸ ਨਾਲ ਲਾਂਬਡਾ ਨੂੰ ਕਾਇਨੇਸਿਸ ਨਾਲ ਇੱਕ ਸਫਲ ਕੁਨੈਕਸ਼ਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਨ ਲਈ ਹੋਰ ਸਮਾਂ ਮਿਲਦਾ ਹੈ। ਪਰਿਵਰਤਨਸ਼ੀਲ ਨੈੱਟਵਰਕ ਲੇਟੈਂਸੀ ਵਾਲੇ ਜਾਂ ਉੱਚ ਮੰਗ ਦੇ ਅਧੀਨ ਸਥਿਤੀਆਂ ਵਿੱਚ ਇਸ ਕਿਸਮ ਦਾ ਅਨੁਕੂਲਨ ਅਕਸਰ ਜ਼ਰੂਰੀ ਹੁੰਦਾ ਹੈ। 🛠️

ਟਾਈਮਆਉਟ ਗਲਤੀਆਂ ਨੂੰ ਘਟਾਉਣ ਦਾ ਇੱਕ ਹੋਰ ਮੁੱਖ ਪਹਿਲੂ ਡਾਟਾ ਏਨਕੋਡਿੰਗ ਅਤੇ ਵਿਭਾਜਨ ਨੂੰ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਪ੍ਰਬੰਧਿਤ ਕਰਨਾ ਹੈ। AWS Kinesis ਨੂੰ ਬਾਈਨਰੀ ਫਾਰਮੈਟ ਵਿੱਚ ਡੇਟਾ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ, ਜਿਸ ਰਾਹੀਂ ਪ੍ਰਾਪਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ TextEncoder().encode(). ਇਹ ਪਰਿਵਰਤਨ ਕਿਨੇਸਿਸ ਨੂੰ ਡੇਟਾ ਟ੍ਰਾਂਸਫਰ ਦੀ ਅਨੁਕੂਲਤਾ ਅਤੇ ਸੁਚਾਰੂਤਾ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਸੋਚ-ਸਮਝ ਕੇ ਭਾਗ ਕੁੰਜੀ ਪ੍ਰਬੰਧਨ ਮਹੱਤਵਪੂਰਨ ਹੈ। ਇਕਸਾਰ ਜਾਂ ਗਤੀਸ਼ੀਲ ਤੌਰ 'ਤੇ ਤਿਆਰ ਕੀਤੀ ਪਾਰਟੀਸ਼ਨ ਕੁੰਜੀ ਦੀ ਵਰਤੋਂ ਕਰਨਾ "ਹੌਟ ਸ਼ਾਰਡਜ਼" ਤੋਂ ਬਚਦੇ ਹੋਏ, ਕਾਇਨੇਸਿਸ ਸ਼ਾਰਡਾਂ ਵਿੱਚ ਡੇਟਾ ਨੂੰ ਸਮਾਨ ਰੂਪ ਵਿੱਚ ਵੰਡਣ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ, ਜੋ ਕਿ ਰਿਕਾਰਡਾਂ ਦੀ ਇੱਕ ਅਨੁਪਾਤਕ ਸੰਖਿਆ ਪ੍ਰਾਪਤ ਕਰਨ ਵਾਲੇ ਸ਼ਾਰਡ ਹਨ। ਉੱਚ-ਫ੍ਰੀਕੁਐਂਸੀ ਸਟ੍ਰੀਮਿੰਗ ਦ੍ਰਿਸ਼ਾਂ ਵਿੱਚ, ਗਤੀਸ਼ੀਲ ਕੁੰਜੀਆਂ ਰੁਕਾਵਟਾਂ ਨੂੰ ਰੋਕ ਸਕਦੀਆਂ ਹਨ ਅਤੇ ਕਨੈਕਟੀਵਿਟੀ ਮੁੱਦਿਆਂ ਦੀ ਸੰਭਾਵਨਾ ਨੂੰ ਘਟਾ ਸਕਦੀਆਂ ਹਨ, ਖਾਸ ਤੌਰ 'ਤੇ ਵੱਡੇ ਡੇਟਾਸੇਟਾਂ ਨੂੰ ਸੰਭਾਲਣ ਵੇਲੇ ਉਪਯੋਗੀ।

ਇਹਨਾਂ Lambda-Kinesis ਪਰਸਪਰ ਕ੍ਰਿਆਵਾਂ ਦੀ ਭਰੋਸੇਯੋਗਤਾ ਨੂੰ ਹੱਲ ਕਰਨ ਅਤੇ ਬਿਹਤਰ ਬਣਾਉਣ ਲਈ, ਯੂਨਿਟ ਟੈਸਟਾਂ ਨੂੰ ਜੋੜਨਾ ਜ਼ਰੂਰੀ ਹੈ। ਯੂਨਿਟ ਟੈਸਟ ਤੁਹਾਨੂੰ ਸੰਭਾਵੀ ਨੈੱਟਵਰਕ ਮੁੱਦਿਆਂ ਦੀ ਨਕਲ ਕਰਨ, ਡੇਟਾ ਏਨਕੋਡਿੰਗ ਨੂੰ ਪ੍ਰਮਾਣਿਤ ਕਰਨ, ਅਤੇ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੇ ਹਨ ਕਿ ਫੰਕਸ਼ਨ ਦੁਬਾਰਾ ਕੋਸ਼ਿਸ਼ਾਂ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਸੰਭਾਲ ਸਕਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਮਖੌਲ ਕਰਕੇ KinesisClient ਯੂਨਿਟ ਟੈਸਟਾਂ ਵਿੱਚ, ਤੁਸੀਂ ਕਿਨੇਸਿਸ ਤੋਂ ਜਵਾਬਾਂ ਦੀ ਇੱਕ ਸ਼੍ਰੇਣੀ ਦੀ ਨਕਲ ਕਰ ਸਕਦੇ ਹੋ, ਜਿਵੇਂ ਕਿ ਸਮਾਂ ਖ਼ਤਮ ਤਰੁੱਟੀਆਂ ਜਾਂ ਸਫਲਤਾ ਦੇ ਕੇਸ, ਜੋ ਕਿ ਲਾਂਬਡਾ ਕੋਡ ਦੇ ਅੰਦਰ ਗਲਤੀ ਨਾਲ ਨਜਿੱਠਣ ਅਤੇ ਕੁਨੈਕਸ਼ਨ ਪ੍ਰਬੰਧਨ ਨੂੰ ਠੀਕ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ। ਵਿਕਾਸ ਵਿੱਚ ਅਜਿਹੇ ਗਲਤੀ ਦੇ ਮਾਮਲਿਆਂ ਦੀ ਜਾਂਚ ਕਰਨ ਨਾਲ ਵਧੇਰੇ ਲਚਕੀਲਾ ਤੈਨਾਤੀ ਹੋ ਸਕਦੀ ਹੈ, ਉਤਪਾਦਨ ਵਿੱਚ ਸਮਾਂ ਸਮਾਪਤ ਹੋਣ ਦੀ ਸੰਭਾਵਨਾ ਨੂੰ ਘਟਾਉਂਦਾ ਹੈ ਅਤੇ ਤੁਹਾਡੀ ਸੰਰਚਨਾ ਵਿੱਚ ਕਮਜ਼ੋਰ ਬਿੰਦੂਆਂ ਦੀ ਪਛਾਣ ਕਰਨਾ ਸੌਖਾ ਬਣਾਉਂਦਾ ਹੈ।