В ਆਖਰੀ ਲੇਖ ਅਸੀਂ ਫਾਲਟ ਸਹਿਣਸ਼ੀਲਤਾ ਅਤੇ ਉੱਚ ਉਪਲਬਧਤਾ ਲਈ RabbitMQ ਕਲੱਸਟਰਿੰਗ ਨੂੰ ਕਵਰ ਕੀਤਾ ਹੈ। ਹੁਣ ਆਓ Apache Kafka ਵਿੱਚ ਹੋਰ ਡੂੰਘਾਈ ਨਾਲ ਜਾਣੀਏ।

ਇੱਥੇ, ਪ੍ਰਤੀਕ੍ਰਿਤੀ ਦੀ ਇਕਾਈ ਭਾਗ ਹੈ। ਹਰੇਕ ਵਿਸ਼ੇ ਵਿੱਚ ਇੱਕ ਜਾਂ ਵੱਧ ਭਾਗ ਹੁੰਦੇ ਹਨ। ਹਰੇਕ ਭਾਗ ਵਿੱਚ ਇੱਕ ਲੀਡਰ ਹੁੰਦਾ ਹੈ, ਫਾਲੋਅਰਜ਼ ਦੇ ਨਾਲ ਜਾਂ ਬਿਨਾਂ। ਵਿਸ਼ਾ ਬਣਾਉਂਦੇ ਸਮੇਂ, ਭਾਗਾਂ ਦੀ ਗਿਣਤੀ ਅਤੇ ਪ੍ਰਤੀਕ੍ਰਿਤੀ ਕਾਰਕ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਆਮ ਮੁੱਲ 3 ਹੈ, ਭਾਵ ਤਿੰਨ ਪ੍ਰਤੀਕ੍ਰਿਤੀਆਂ: ਇੱਕ ਨੇਤਾ ਅਤੇ ਦੋ ਅਨੁਯਾਈ।

ਚਿੱਤਰ 1. ਤਿੰਨ ਦਲਾਲਾਂ ਵਿੱਚ ਚਾਰ ਭਾਗ ਵੰਡੇ ਗਏ ਹਨ।

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

ਭਾਗ ਅਸਫਲਤਾ

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

ਬ੍ਰੋਕਰ 3 ਨੈੱਟਵਰਕ ਛੱਡ ਦਿੰਦਾ ਹੈ, ਅਤੇ ਬ੍ਰੋਕਰ 2 'ਤੇ ਪਾਰਟੀਸ਼ਨ 2 ਲਈ ਇੱਕ ਨਵਾਂ ਲੀਡਰ ਚੁਣਿਆ ਜਾਂਦਾ ਹੈ।

ਚਿੱਤਰ 2. ਬ੍ਰੋਕਰ 3 ਦੀ ਮੌਤ ਹੋ ਜਾਂਦੀ ਹੈ ਅਤੇ ਬ੍ਰੋਕਰ 2 'ਤੇ ਇਸਦੇ ਅਨੁਯਾਈ ਨੂੰ ਵੰਡ 2 ਦੇ ਨਵੇਂ ਨੇਤਾ ਵਜੋਂ ਚੁਣਿਆ ਜਾਂਦਾ ਹੈ।

ਫਿਰ ਬ੍ਰੋਕਰ 1 ਚਲਾ ਜਾਂਦਾ ਹੈ ਅਤੇ ਸੈਕਸ਼ਨ 1 ਵੀ ਆਪਣਾ ਨੇਤਾ ਗੁਆ ਦਿੰਦਾ ਹੈ, ਜਿਸਦੀ ਭੂਮਿਕਾ ਬ੍ਰੋਕਰ 2 ਨੂੰ ਜਾਂਦੀ ਹੈ।

ਚਿੱਤਰ 3. ਇੱਕ ਬ੍ਰੋਕਰ ਬਾਕੀ ਹੈ। ਸਾਰੇ ਲੀਡਰ ਇੱਕ ਸਿੰਗਲ ਬ੍ਰੋਕਰ 'ਤੇ ਹਨ ਜਿਸ ਵਿੱਚ ਕੋਈ ਰਿਡੰਡੈਂਸੀ ਨਹੀਂ ਹੈ।

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

ਚਿੱਤਰ 4. ਆਗੂ ਬ੍ਰੋਕਰ 2 'ਤੇ ਬਣੇ ਰਹਿੰਦੇ ਹਨ।

ਜਦੋਂ ਬ੍ਰੋਕਰ 3 ਵਧਦਾ ਹੈ, ਅਸੀਂ ਪ੍ਰਤੀ ਭਾਗ ਤਿੰਨ ਪ੍ਰਤੀਕ੍ਰਿਤੀਆਂ ਤੇ ਵਾਪਸ ਆਉਂਦੇ ਹਾਂ। ਪਰ ਸਾਰੇ ਨੇਤਾ ਅਜੇ ਵੀ ਬ੍ਰੋਕਰ 2 ਤੇ ਹਨ।

ਚਿੱਤਰ 5. ਦਲਾਲ 1 ਅਤੇ 3 ਦੀ ਰਿਕਵਰੀ ਤੋਂ ਬਾਅਦ ਅਸੰਤੁਲਿਤ ਲੀਡਰ ਪਲੇਸਮੈਂਟ

ਕਾਫਕਾ ਕੋਲ ਰੈਬਿਟਐਮਕਿਊ ਨਾਲੋਂ ਲੀਡਰ ਰੀਬੈਲੈਂਸਿੰਗ ਲਈ ਵਧੇਰੇ ਕੁਸ਼ਲ ਟੂਲ ਹੈ। ਉੱਥੇ, ਸਾਨੂੰ ਇੱਕ ਤੀਜੀ-ਧਿਰ ਪਲੱਗਇਨ ਜਾਂ ਸਕ੍ਰਿਪਟ ਦੀ ਵਰਤੋਂ ਕਰਨੀ ਪਈ ਜਿਸਨੇ ਮਾਈਗ੍ਰੇਸ਼ਨ ਦੌਰਾਨ ਰਿਡੰਡੈਂਸੀ ਨੂੰ ਘਟਾ ਕੇ ਮਾਸਟਰ ਨੋਡ ਮਾਈਗ੍ਰੇਸ਼ਨ ਨੀਤੀਆਂ ਨੂੰ ਸੋਧਿਆ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਵੱਡੀਆਂ ਕਤਾਰਾਂ ਲਈ, ਸਾਨੂੰ ਸਿੰਕ੍ਰੋਨਾਈਜ਼ੇਸ਼ਨ ਦੌਰਾਨ ਅਣਉਪਲਬਧਤਾ ਨੂੰ ਸਵੀਕਾਰ ਕਰਨਾ ਪਿਆ।

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

ਇਸਨੂੰ ਠੀਕ ਕਰਨ ਲਈ, ਕਾਫਕਾ ਦੋ ਵਿਕਲਪ ਪੇਸ਼ ਕਰਦਾ ਹੈ:

• ਵਿਕਲਪ auto.leader.rebalance.enable=true ਕੰਟਰੋਲਰ ਨੋਡ ਨੂੰ ਆਪਣੇ ਆਪ ਹੀ ਲੀਡਰਾਂ ਨੂੰ ਪਸੰਦੀਦਾ ਪ੍ਰਤੀਕ੍ਰਿਤੀਆਂ ਵਿੱਚ ਵਾਪਸ ਸੌਂਪਣ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ ਅਤੇ ਇਸ ਤਰ੍ਹਾਂ ਇੱਕ ਸਮਾਨ ਵੰਡ ਨੂੰ ਬਹਾਲ ਕਰਦਾ ਹੈ।
• ਪ੍ਰਸ਼ਾਸਕ ਸਕ੍ਰਿਪਟ ਚਲਾ ਸਕਦਾ ਹੈ। kafka-preferred-replica-election.sh ਵੱਲੋਂ ਹੋਰ ਹੱਥੀਂ ਮੁੜ-ਨਿਰਧਾਰਨ ਲਈ।

ਚਿੱਤਰ 6. ਮੁੜ ਸੰਤੁਲਨ ਤੋਂ ਬਾਅਦ ਪ੍ਰਤੀਕ੍ਰਿਤੀਆਂ

ਇਹ ਅਸਫਲਤਾ ਦਾ ਇੱਕ ਸਰਲ ਰੂਪ ਸੀ, ਪਰ ਅਸਲੀਅਤ ਵਧੇਰੇ ਗੁੰਝਲਦਾਰ ਹੈ, ਹਾਲਾਂਕਿ ਇੱਥੇ ਕੁਝ ਵੀ ਬਹੁਤ ਜ਼ਿਆਦਾ ਗੁੰਝਲਦਾਰ ਨਹੀਂ ਹੈ। ਇਹ ਸਭ ਇਨ-ਸਿੰਕ ਪ੍ਰਤੀਕ੍ਰਿਤੀਆਂ (ISRs) 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ।

ਸਿੰਕ੍ਰੋਨਾਈਜ਼ਡ ਪ੍ਰਤੀਕ੍ਰਿਤੀਆਂ (ISR)

ਇੱਕ ISR ਭਾਗ ਪ੍ਰਤੀਕ੍ਰਿਤੀਆਂ ਦਾ ਇੱਕ ਸਮੂਹ ਹੈ ਜਿਸਨੂੰ "ਇਨ-ਸਿੰਕ" ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ। ਇੱਕ ਲੀਡਰ ਹੁੰਦਾ ਹੈ, ਪਰ ਕੋਈ ਫਾਲੋਅਰ ਨਹੀਂ ਹੋ ਸਕਦਾ। ਇੱਕ ਫਾਲੋਅਰ ਨੂੰ ਇਨ-ਸਿੰਕ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ ਜੇਕਰ ਉਸਨੇ ਅੰਤਰਾਲ ਦੀ ਮਿਆਦ ਪੁੱਗਣ ਤੋਂ ਪਹਿਲਾਂ ਸਾਰੇ ਲੀਡਰ ਦੇ ਸੁਨੇਹਿਆਂ ਦੀਆਂ ਸਹੀ ਕਾਪੀਆਂ ਬਣਾ ਲਈਆਂ ਹਨ। ਪ੍ਰਤੀਕ੍ਰਿਤੀ.ਲੈਗ.ਟਾਈਮ.ਮੈਕਸ.ਐਮਐਸ.

ਇੱਕ ਫਾਲੋਅਰ ਨੂੰ ISR ਸੈੱਟ ਤੋਂ ਹਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ ਜੇਕਰ ਉਹ:

• ਅੰਤਰਾਲ ਦੇ ਅੰਦਰ ਸੈਂਪਲਿੰਗ ਲਈ ਬੇਨਤੀ ਨਹੀਂ ਕੀਤੀ ਪ੍ਰਤੀਕ੍ਰਿਤੀ.ਲੈਗ.ਟਾਈਮ.ਮੈਕਸ.ਐਮਐਸ (ਮ੍ਰਿਤਕ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ)
• ਅੰਤਰਾਲ ਦੌਰਾਨ ਅੱਪਡੇਟ ਕਰਨ ਲਈ ਸਮਾਂ ਨਹੀਂ ਸੀ। ਪ੍ਰਤੀਕ੍ਰਿਤੀ.ਲੈਗ.ਟਾਈਮ.ਮੈਕਸ.ਐਮਐਸ (ਹੌਲੀ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ)

ਫਾਲੋਅਰਜ਼ ਅੰਤਰਾਲ ਵਿੱਚ ਚੋਣ ਲਈ ਬੇਨਤੀਆਂ ਕਰਦੇ ਹਨ। ਪ੍ਰਤੀਕ੍ਰਿਤੀ.ਫੈਚ.ਉਡੀਕ.ਵੱਧ ਤੋਂ ਵੱਧ.ਮਿਸੇਜ਼, ਜੋ ਕਿ ਡਿਫਾਲਟ ਤੌਰ 'ਤੇ 500 ms ਹੈ।

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

• acks=0, ਪੁਸ਼ਟੀ ਨਹੀਂ ਭੇਜੀ ਗਈ
• acks=1, ਲੀਡਰ ਦੁਆਰਾ ਆਪਣੇ ਸਥਾਨਕ ਲੌਗ ਵਿੱਚ ਸੁਨੇਹਾ ਲਿਖਣ ਤੋਂ ਬਾਅਦ ਇੱਕ ਰਸੀਦ ਭੇਜੀ ਜਾਂਦੀ ਹੈ।
• acks=all, ISR ਵਿੱਚ ਸਾਰੀਆਂ ਪ੍ਰਤੀਕ੍ਰਿਤੀਆਂ ਦੁਆਰਾ ਆਪਣੇ ਸਥਾਨਕ ਲੌਗਾਂ ਵਿੱਚ ਸੁਨੇਹਾ ਲਿਖਣ ਤੋਂ ਬਾਅਦ ਰਸੀਦ ਭੇਜੀ ਜਾਂਦੀ ਹੈ।

ਕਾਫਕਾ ਸ਼ਬਦਾਵਲੀ ਵਿੱਚ, ਜੇਕਰ ਕਿਸੇ ISR ਨੇ ਇੱਕ ਸੁਨੇਹਾ ਸੁਰੱਖਿਅਤ ਕੀਤਾ ਹੈ, ਤਾਂ ਇਹ "ਪ੍ਰਤੀਬੱਧ" ਹੈ। Acks=all ਸਭ ਤੋਂ ਸੁਰੱਖਿਅਤ ਵਿਕਲਪ ਹੈ, ਪਰ ਇਹ ਵਾਧੂ ਲੇਟੈਂਸੀ ਵੀ ਪੇਸ਼ ਕਰਦਾ ਹੈ। ਆਓ ਦੋ ਅਸਫਲਤਾ ਉਦਾਹਰਣਾਂ 'ਤੇ ਨਜ਼ਰ ਮਾਰੀਏ ਅਤੇ ਵੱਖ-ਵੱਖ 'acks' ਵਿਕਲਪ ISR ਸੰਕਲਪ ਨਾਲ ਕਿਵੇਂ ਪਰਸਪਰ ਪ੍ਰਭਾਵ ਪਾਉਂਦੇ ਹਨ।

Acks=1 ਅਤੇ ISR

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

ਇਸ ਉਦਾਹਰਣ ਵਿੱਚ, ਨਿਰਮਾਤਾ ਕੋਲ acks=1 ਹੈ। ਭਾਗ ਤਿੰਨਾਂ ਬ੍ਰੋਕਰਾਂ ਵਿੱਚ ਵੰਡਿਆ ਗਿਆ ਹੈ। ਬ੍ਰੋਕਰ 3 ਪਿੱਛੇ ਹੈ; ਇਹ ਅੱਠ ਸਕਿੰਟ ਪਹਿਲਾਂ ਲੀਡਰ ਨਾਲ ਸਿੰਕ ਹੋਇਆ ਸੀ ਅਤੇ ਹੁਣ 7456 ਸੁਨੇਹੇ ਪਿੱਛੇ ਹੈ। ਬ੍ਰੋਕਰ 1 ਸਿਰਫ਼ ਇੱਕ ਸਕਿੰਟ ਪਿੱਛੇ ਹੈ। ਸਾਡਾ ਨਿਰਮਾਤਾ ਇੱਕ ਸੁਨੇਹਾ ਭੇਜਦਾ ਹੈ ਅਤੇ ਇੱਕ ack ਬੈਕ ਤੇਜ਼ੀ ਨਾਲ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ, ਬਿਨਾਂ ਕਿਸੇ ਹੌਲੀ ਜਾਂ ਮ੍ਰਿਤ ਫਾਲੋਅਰਜ਼ ਤੋਂ ਓਵਰਹੈੱਡ ਦੇ ਜਿਸਦੀ ਲੀਡਰ ਉਮੀਦ ਨਹੀਂ ਕਰ ਰਿਹਾ ਹੈ।

ਚਿੱਤਰ 7. ਤਿੰਨ ਪ੍ਰਤੀਕ੍ਰਿਤੀਆਂ ਵਾਲਾ ISR

ਬ੍ਰੋਕਰ 2 ਕਰੈਸ਼ ਹੋ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਨਿਰਮਾਤਾ ਨੂੰ ਇੱਕ ਕਨੈਕਸ਼ਨ ਗਲਤੀ ਮਿਲਦੀ ਹੈ। ਲੀਡਰਸ਼ਿਪ ਦੇ ਬ੍ਰੋਕਰ 1 ਵਿੱਚ ਤਬਦੀਲੀ ਤੋਂ ਬਾਅਦ, ਅਸੀਂ 123 ਸੁਨੇਹੇ ਗੁਆ ਦਿੰਦੇ ਹਾਂ। ਬ੍ਰੋਕਰ 1 'ਤੇ ਇੱਕ ਫਾਲੋਅਰ ISR ਵਿੱਚ ਲੌਗਇਨ ਕੀਤਾ ਗਿਆ ਸੀ ਪਰ ਜਦੋਂ ਲੀਡਰ ਕਰੈਸ਼ ਹੋਇਆ ਤਾਂ ਲੀਡਰ ਨਾਲ ਪੂਰੀ ਤਰ੍ਹਾਂ ਸਿੰਕ੍ਰੋਨਾਈਜ਼ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਸੀ।

ਚਿੱਤਰ 8. ਕਰੈਸ਼ ਦੌਰਾਨ ਸੁਨੇਹੇ ਗੁੰਮ ਹੋ ਜਾਂਦੇ ਹਨ।

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

ਚਿੱਤਰ 9. ਥੋੜ੍ਹੇ ਜਿਹੇ ਬ੍ਰੇਕ ਤੋਂ ਬਾਅਦ ਸੁਨੇਹਾ ਭੇਜਣਾ ਰੈਜ਼ਿਊਮੇ

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

ਚਿੱਤਰ 10. ਬ੍ਰੋਕਰ 3 'ਤੇ ਫਾਲੋਅਰ ਨੂੰ ISR ਤੋਂ ਹਟਾ ਦਿੱਤਾ ਗਿਆ ਹੈ।

ਬ੍ਰੋਕਰ 1 ਕਰੈਸ਼ ਹੋ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਬ੍ਰੋਕਰ 3 ਲੀਡਰਸ਼ਿਪ ਸੰਭਾਲ ਲੈਂਦਾ ਹੈ, 15286 ਸੁਨੇਹੇ ਗੁਆ ਦਿੰਦਾ ਹੈ! ਨਿਰਮਾਤਾ ਨੂੰ ਇੱਕ ਕਨੈਕਸ਼ਨ ਗਲਤੀ ਮਿਲਦੀ ਹੈ। ISR ਤੋਂ ਬਾਹਰ ਲੀਡਰਸ਼ਿਪ ਅਸਫਲਤਾ ਸਿਰਫ ਇੱਕ ਕੌਂਫਿਗਰੇਸ਼ਨ ਗਲਤੀ ਕਾਰਨ ਸੰਭਵ ਸੀ। unclean.leader.election.enable=ਸੱਚ. ਜੇਕਰ ਇਹ ਵਿੱਚ ਸਥਾਪਿਤ ਹੈ ਝੂਠੇ, ਤਬਦੀਲੀ ਨਹੀਂ ਹੁੰਦੀ, ਅਤੇ ਸਾਰੀਆਂ ਪੜ੍ਹਨ ਅਤੇ ਲਿਖਣ ਦੀਆਂ ਬੇਨਤੀਆਂ ਨੂੰ ਰੱਦ ਕਰ ਦਿੱਤਾ ਜਾਂਦਾ। ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਅਸੀਂ ਬ੍ਰੋਕਰ 1 ਦੇ ਪ੍ਰਤੀਕ੍ਰਿਤੀ ਵਿੱਚ ਆਪਣੇ ਬਰਕਰਾਰ ਡੇਟਾ ਦੇ ਨਾਲ ਵਾਪਸ ਆਉਣ ਦੀ ਉਡੀਕ ਕਰਦੇ ਹਾਂ, ਜੋ ਇੱਕ ਵਾਰ ਫਿਰ ਲੀਡਰਸ਼ਿਪ ਸੰਭਾਲ ਲਵੇਗਾ।

ਚਿੱਤਰ 11. ਬ੍ਰੋਕਰ 1 ਕਰੈਸ਼ ਹੋ ਜਾਂਦਾ ਹੈ। ਕਰੈਸ਼ ਦੌਰਾਨ ਵੱਡੀ ਗਿਣਤੀ ਵਿੱਚ ਸੁਨੇਹੇ ਗੁੰਮ ਹੋ ਜਾਂਦੇ ਹਨ।

ਨਿਰਮਾਤਾ ਆਖਰੀ ਬ੍ਰੋਕਰ ਨਾਲ ਇੱਕ ਸੰਬੰਧ ਸਥਾਪਿਤ ਕਰਦਾ ਹੈ ਅਤੇ ਦੇਖਦਾ ਹੈ ਕਿ ਇਹ ਹੁਣ ਪਾਰਟੀਸ਼ਨ ਲੀਡਰ ਹੈ। ਇਹ ਬ੍ਰੋਕਰ 3 ਨੂੰ ਸੁਨੇਹੇ ਭੇਜਣਾ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ।

ਚਿੱਤਰ 12. ਥੋੜ੍ਹੇ ਜਿਹੇ ਬ੍ਰੇਕ ਤੋਂ ਬਾਅਦ, ਸੁਨੇਹੇ ਦੁਬਾਰਾ ਭਾਗ 0 ਤੇ ਭੇਜੇ ਜਾਂਦੇ ਹਨ।

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

Acks=ਸਾਰੇ ਅਤੇ ISR

ਆਓ ਇਸ ਦ੍ਰਿਸ਼ ਨੂੰ ਦੁਬਾਰਾ ਦੁਹਰਾਈਏ, ਪਰ ਨਾਲ acks=ਸਾਰੇਬ੍ਰੋਕਰ 3 ਦੀ ਦੇਰੀ ਔਸਤਨ ਚਾਰ ਸਕਿੰਟ ਹੈ। ਨਿਰਮਾਤਾ ਇੱਕ ਸੁਨੇਹਾ ਭੇਜਦਾ ਹੈ acks=ਸਾਰੇ, ਅਤੇ ਹੁਣ ਕੋਈ ਤੁਰੰਤ ਜਵਾਬ ਨਹੀਂ ਮਿਲਦਾ। ਲੀਡਰ ਸੁਨੇਹੇ ਨੂੰ ਸਟੋਰ ਕਰਨ ਲਈ ISR ਵਿੱਚ ਸਾਰੀਆਂ ਪ੍ਰਤੀਕ੍ਰਿਤੀਆਂ ਦੀ ਉਡੀਕ ਕਰਦਾ ਹੈ।

ਚਿੱਤਰ 13. ਤਿੰਨ ਪ੍ਰਤੀਕ੍ਰਿਤੀਆਂ ਵਾਲਾ ISR। ਇੱਕ ਹੌਲੀ ਹੈ, ਜਿਸ ਕਾਰਨ ਲਿਖਣ ਵਿੱਚ ਦੇਰੀ ਹੋ ਰਹੀ ਹੈ।

ਚਾਰ ਸਕਿੰਟਾਂ ਦੀ ਵਾਧੂ ਦੇਰੀ ਤੋਂ ਬਾਅਦ, ਬ੍ਰੋਕਰ 2 ਇੱਕ ack ਭੇਜਦਾ ਹੈ। ਸਾਰੀਆਂ ਪ੍ਰਤੀਕ੍ਰਿਤੀਆਂ ਹੁਣ ਪੂਰੀ ਤਰ੍ਹਾਂ ਅੱਪਡੇਟ ਹੋ ਗਈਆਂ ਹਨ।

ਚਿੱਤਰ 14. ਸਾਰੀਆਂ ਪ੍ਰਤੀਕ੍ਰਿਤੀਆਂ ਸੁਨੇਹੇ ਸੇਵ ਕਰਦੀਆਂ ਹਨ ਅਤੇ ਇੱਕ ack ਭੇਜਿਆ ਜਾਂਦਾ ਹੈ।

ਬ੍ਰੋਕਰ 3 ਹੁਣ ਹੋਰ ਵੀ ਪਿੱਛੇ ਰਹਿ ਗਿਆ ਹੈ ਅਤੇ ISR ਤੋਂ ਹਟਾ ਦਿੱਤਾ ਗਿਆ ਹੈ। ਲੇਟੈਂਸੀ ਕਾਫ਼ੀ ਘੱਟ ਗਈ ਹੈ ਕਿਉਂਕਿ ISR ਵਿੱਚ ਹੁਣ ਕੋਈ ਹੌਲੀ ਪ੍ਰਤੀਕ੍ਰਿਤੀਆਂ ਨਹੀਂ ਹਨ। ਬ੍ਰੋਕਰ 2 ਹੁਣ ਸਿਰਫ਼ ਬ੍ਰੋਕਰ 1 ਦੀ ਉਡੀਕ ਕਰਦਾ ਹੈ, ਜਿਸਦਾ ਔਸਤ ਲੈਗ 500 ms ਹੈ।

ਚਿੱਤਰ 15. ਬ੍ਰੋਕਰ 3 'ਤੇ ਪ੍ਰਤੀਕ੍ਰਿਤੀ ISR ਤੋਂ ਹਟਾ ਦਿੱਤੀ ਗਈ ਹੈ।

ਫਿਰ ਬ੍ਰੋਕਰ 2 ਕਰੈਸ਼ ਹੋ ਜਾਂਦਾ ਹੈ ਅਤੇ ਲੀਡਰਸ਼ਿਪ ਸੁਨੇਹੇ ਗੁਆਏ ਬਿਨਾਂ ਬ੍ਰੋਕਰ 1 ਨੂੰ ਪਾਸ ਹੋ ਜਾਂਦੀ ਹੈ।

ਚਿੱਤਰ 16. ਬ੍ਰੋਕਰ 2 ਡਿੱਗਦਾ ਹੈ

ਨਿਰਮਾਤਾ ਇੱਕ ਨਵਾਂ ਲੀਡਰ ਲੱਭਦਾ ਹੈ ਅਤੇ ਉਸਨੂੰ ਸੁਨੇਹੇ ਭੇਜਣਾ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ। ਲੇਟੈਂਸੀ ਹੋਰ ਵੀ ਘੱਟ ਜਾਂਦੀ ਹੈ, ਕਿਉਂਕਿ ISR ਵਿੱਚ ਹੁਣ ਇੱਕ ਸਿੰਗਲ ਪ੍ਰਤੀਕ੍ਰਿਤੀ ਹੁੰਦੀ ਹੈ! ਇਸ ਲਈ, ਵਿਕਲਪ acks=ਸਾਰੇ ਰਿਡੰਡੈਂਸੀ ਨਹੀਂ ਜੋੜਦਾ।

ਚਿੱਤਰ 17. ਬ੍ਰੋਕਰ 1 'ਤੇ ਪ੍ਰਤੀਕ੍ਰਿਤੀ ਸੁਨੇਹੇ ਗੁਆਏ ਬਿਨਾਂ ਲੀਡਰਸ਼ਿਪ ਸੰਭਾਲਦੀ ਹੈ।

ਫਿਰ ਬ੍ਰੋਕਰ 1 ਡਿੱਗਦਾ ਹੈ ਅਤੇ ਲੀਡ ਬ੍ਰੋਕਰ 3 ਨੂੰ ਜਾਂਦੀ ਹੈ ਜਿਸ ਨਾਲ 14238 ਸੁਨੇਹੇ ਖਤਮ ਹੋ ਜਾਂਦੇ ਹਨ!

ਚਿੱਤਰ 18. ਬ੍ਰੋਕਰ 1 ਦੀ ਮੌਤ ਹੋ ਜਾਂਦੀ ਹੈ ਅਤੇ ਅਸ਼ੁੱਧ ਸੈੱਟਅੱਪ ਨਾਲ ਲੀਡਰਸ਼ਿਪ ਤਬਦੀਲੀ ਦੇ ਨਤੀਜੇ ਵਜੋਂ ਭਾਰੀ ਡੇਟਾ ਦਾ ਨੁਕਸਾਨ ਹੁੰਦਾ ਹੈ।

ਅਸੀਂ ਵਿਕਲਪ ਸਥਾਪਤ ਨਹੀਂ ਕਰ ਸਕਦੇ ਸੀ। ਅਣਚਾਹੇ.ਨੇਤਾ.ਚੋਣ.ਯੋਗ ਅਰਥ ਵਿੱਚ ਇਹ ਸੱਚ ਹੈ,. ਡਿਫਾਲਟ ਤੌਰ 'ਤੇ ਇਹ ਬਰਾਬਰ ਹੁੰਦਾ ਹੈ ਝੂਠੇ. ਸੈੱਟਅੱਪ ਕਰਨਾ acks=ਸਾਰੇ с unclean.leader.election.enable=ਸੱਚ ਕੁਝ ਵਾਧੂ ਡਾਟਾ ਸੁਰੱਖਿਆ ਦੇ ਨਾਲ ਉਪਲਬਧਤਾ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। ਪਰ ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ ਦੇਖ ਸਕਦੇ ਹੋ, ਅਸੀਂ ਅਜੇ ਵੀ ਸੁਨੇਹੇ ਗੁਆ ਸਕਦੇ ਹਾਂ।

ਪਰ ਜੇ ਅਸੀਂ ਡੇਟਾ ਸੁਰੱਖਿਆ ਵਧਾਉਣਾ ਚਾਹੁੰਦੇ ਹਾਂ ਤਾਂ ਕੀ ਹੋਵੇਗਾ? ਅਸੀਂ ਸੈੱਟ ਕਰ ਸਕਦੇ ਹਾਂ unclean.leader.election.enable = ਗਲਤ, ਪਰ ਇਹ ਜ਼ਰੂਰੀ ਨਹੀਂ ਕਿ ਸਾਨੂੰ ਡੇਟਾ ਦੇ ਨੁਕਸਾਨ ਤੋਂ ਬਚਾਏਗਾ। ਜੇਕਰ ਲੀਡਰ ਜ਼ੋਰ ਨਾਲ ਕਰੈਸ਼ ਹੋ ਜਾਂਦਾ ਹੈ ਅਤੇ ਡੇਟਾ ਨੂੰ ਆਪਣੇ ਨਾਲ ਲੈ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਸੁਨੇਹੇ ਅਜੇ ਵੀ ਗੁੰਮ ਹੋ ਜਾਂਦੇ ਹਨ, ਨਾਲ ਹੀ ਪਹੁੰਚਯੋਗਤਾ ਉਦੋਂ ਤੱਕ ਖਤਮ ਹੋ ਜਾਂਦੀ ਹੈ ਜਦੋਂ ਤੱਕ ਪ੍ਰਸ਼ਾਸਕ ਸਥਿਤੀ ਨੂੰ ਬਹਾਲ ਨਹੀਂ ਕਰਦਾ।

ਸਾਰੇ ਸੁਨੇਹਿਆਂ ਦੀ ਰਿਡੰਡੈਂਸੀ ਦੀ ਗਰੰਟੀ ਦੇਣਾ ਬਿਹਤਰ ਹੈ, ਜਾਂ ਨਹੀਂ ਤਾਂ ਲਿਖਤ ਨੂੰ ਰੱਦ ਕਰ ਦੇਣਾ ਚਾਹੀਦਾ ਹੈ। ਫਿਰ, ਘੱਟੋ ਘੱਟ ਬ੍ਰੋਕਰ ਦੇ ਦ੍ਰਿਸ਼ਟੀਕੋਣ ਤੋਂ, ਡੇਟਾ ਦਾ ਨੁਕਸਾਨ ਸਿਰਫ ਤਾਂ ਹੀ ਸੰਭਵ ਹੈ ਜੇਕਰ ਦੋ ਜਾਂ ਦੋ ਤੋਂ ਵੱਧ ਇੱਕੋ ਸਮੇਂ ਅਸਫਲਤਾਵਾਂ ਹੁੰਦੀਆਂ ਹਨ।

Acks=all, min.insync.replicas ਅਤੇ ISR

ਵਿਸ਼ਾ ਸੰਰਚਨਾ ਦੇ ਨਾਲ min.insync.replicas ਅਸੀਂ ਡੇਟਾ ਸੁਰੱਖਿਆ ਦੇ ਪੱਧਰ ਨੂੰ ਵਧਾ ਰਹੇ ਹਾਂ। ਆਓ ਪਿਛਲੇ ਦ੍ਰਿਸ਼ ਦੇ ਆਖਰੀ ਹਿੱਸੇ 'ਤੇ ਦੁਬਾਰਾ ਵਿਚਾਰ ਕਰੀਏ, ਪਰ ਇਸ ਵਾਰ ਘੱਟੋ-ਘੱਟ.ਇਨਸਿੰਕ.ਪ੍ਰਤੀਕ੍ਰਿਤੀਆਂ=2.

ਇਸ ਲਈ, ਬ੍ਰੋਕਰ 2 ਕੋਲ ਇੱਕ ਪ੍ਰਤੀਕ੍ਰਿਤੀ ਲੀਡਰ ਹੈ, ਅਤੇ ਬ੍ਰੋਕਰ 3 ਦੇ ਫਾਲੋਅਰ ਨੂੰ ISR ਤੋਂ ਹਟਾ ਦਿੱਤਾ ਗਿਆ ਹੈ।

ਚਿੱਤਰ 19. ਦੋ ਪ੍ਰਤੀਕ੍ਰਿਤੀਆਂ ਤੋਂ ISR

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

ਚਿੱਤਰ 20. ISR ਦੀ ਗਿਣਤੀ min.insync.replicas ਵਿੱਚ ਦਰਸਾਏ ਗਏ ਤੋਂ ਇੱਕ ਘੱਟ ਹੈ।

ਇਹ ਸੰਰਚਨਾ ਇਕਸਾਰਤਾ ਲਈ ਉਪਲਬਧਤਾ ਦੀ ਕੁਰਬਾਨੀ ਦਿੰਦੀ ਹੈ। ਕਿਸੇ ਸੁਨੇਹੇ ਨੂੰ ਸਵੀਕਾਰ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ, ਅਸੀਂ ਗਰੰਟੀ ਦਿੰਦੇ ਹਾਂ ਕਿ ਇਹ ਘੱਟੋ-ਘੱਟ ਦੋ ਪ੍ਰਤੀਕ੍ਰਿਤੀਆਂ ਵਿੱਚ ਲਿਖਿਆ ਗਿਆ ਹੈ। ਇਹ ਨਿਰਮਾਤਾ ਨੂੰ ਬਹੁਤ ਜ਼ਿਆਦਾ ਵਿਸ਼ਵਾਸ ਦਿੰਦਾ ਹੈ। ਸੁਨੇਹਾ ਗੁਆਉਣਾ ਤਾਂ ਹੀ ਸੰਭਵ ਹੈ ਜੇਕਰ ਦੋ ਪ੍ਰਤੀਕ੍ਰਿਤੀਆਂ ਇੱਕ ਵਾਧੂ ਫਾਲੋਅਰ ਨੂੰ ਸੁਨੇਹੇ ਦੀ ਨਕਲ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਇੱਕ ਛੋਟੀ ਜਿਹੀ ਸਮਾਂ-ਸੀਮਾ ਦੇ ਅੰਦਰ ਇੱਕੋ ਸਮੇਂ ਅਸਫਲ ਹੋ ਜਾਂਦੀਆਂ ਹਨ, ਜੋ ਕਿ ਅਸੰਭਵ ਹੈ। ਪਰ ਜੇਕਰ ਤੁਸੀਂ ਬਹੁਤ ਜ਼ਿਆਦਾ ਪਾਗਲ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਪ੍ਰਤੀਕ੍ਰਿਤੀ ਕਾਰਕ ਨੂੰ 5 'ਤੇ ਸੈੱਟ ਕਰ ਸਕਦੇ ਹੋ, ਅਤੇ min.insync.replicas 3. ਰਿਕਾਰਡ ਗੁਆਉਣ ਲਈ ਤਿੰਨ ਬ੍ਰੋਕਰਾਂ ਨੂੰ ਇੱਕੋ ਸਮੇਂ ਕਰੈਸ਼ ਹੋਣਾ ਪਵੇਗਾ! ਬੇਸ਼ੱਕ, ਤੁਹਾਨੂੰ ਇਸ ਭਰੋਸੇਯੋਗਤਾ ਲਈ ਵਾਧੂ ਲੇਟੈਂਸੀ ਦੇ ਨਾਲ ਭੁਗਤਾਨ ਕਰਨਾ ਪਵੇਗਾ।

ਜਦੋਂ ਡਾਟਾ ਸੁਰੱਖਿਆ ਲਈ ਉਪਲਬਧਤਾ ਜ਼ਰੂਰੀ ਹੁੰਦੀ ਹੈ

ਜਿਵੇਂ ਕਿ RabbitMQ ਦੇ ਮਾਮਲੇ ਵਿੱਚਕਈ ਵਾਰ ਡਾਟਾ ਸੁਰੱਖਿਆ ਲਈ ਪਹੁੰਚਯੋਗਤਾ ਜ਼ਰੂਰੀ ਹੁੰਦੀ ਹੈ। ਇੱਥੇ ਤੁਹਾਨੂੰ ਵਿਚਾਰ ਕਰਨ ਦੀ ਲੋੜ ਹੈ:

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

ਜੇਕਰ ਜਵਾਬ ਨਹੀਂ ਹੈ, ਤਾਂ ਉਪਲਬਧਤਾ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਣ ਨਾਲ ਡੇਟਾ ਸੁਰੱਖਿਆ ਵਿੱਚ ਸੁਧਾਰ ਹੁੰਦਾ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ ਲਿਖਣ ਦੀ ਅਸਫਲਤਾ ਦੀ ਬਜਾਏ ਉਪਲਬਧਤਾ ਨੂੰ ਚੁਣਦੇ ਹੋ ਤਾਂ ਤੁਸੀਂ ਘੱਟ ਡੇਟਾ ਗੁਆਓਗੇ। ਇਸ ਲਈ, ਇਹ ਸਭ ਸੰਤੁਲਨ ਲੱਭਣ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ, ਅਤੇ ਫੈਸਲਾ ਖਾਸ ਸਥਿਤੀ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ।

ISR ਦਾ ਅਰਥ

ਇੱਕ ISR ਸੈੱਟ ਤੁਹਾਨੂੰ ਡੇਟਾ ਸੁਰੱਖਿਆ ਅਤੇ ਲੇਟੈਂਸੀ ਵਿਚਕਾਰ ਅਨੁਕੂਲ ਸੰਤੁਲਨ ਚੁਣਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ। ਉਦਾਹਰਣ ਵਜੋਂ, ਇਹ ਜ਼ਿਆਦਾਤਰ ਪ੍ਰਤੀਕ੍ਰਿਤੀਆਂ ਦੇ ਅਸਫਲ ਹੋਣ 'ਤੇ ਵੀ ਉਪਲਬਧਤਾ ਨੂੰ ਯਕੀਨੀ ਬਣਾ ਸਕਦਾ ਹੈ, ਜਦੋਂ ਕਿ ਡੈੱਡ ਜਾਂ ਹੌਲੀ ਪ੍ਰਤੀਕ੍ਰਿਤੀਆਂ ਦੇ ਲੇਟੈਂਸੀ ਪ੍ਰਭਾਵ ਨੂੰ ਘੱਟ ਕਰਦਾ ਹੈ।

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

RabbitMQ ਵਿੱਚ ਸਿਰਫ਼ ਮਿਰਰਾਂ ਦਾ ਇੱਕ ਸੈੱਟ ਹੁੰਦਾ ਹੈ ਜਿਨ੍ਹਾਂ ਨੂੰ ਦੁਹਰਾਉਣ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਹੌਲੀ ਮਿਰਰ ਵਾਧੂ ਲੇਟੈਂਸੀ ਪੇਸ਼ ਕਰਦੇ ਹਨ, ਅਤੇ ਡੈੱਡ ਮਿਰਰ ਜਵਾਬ ਦੇਣ ਲਈ ਇੱਕ ਨੈੱਟਵਰਕ ਟਿੱਕ ਤੱਕ ਲੈ ਸਕਦੇ ਹਨ। ISR ਇਹਨਾਂ ਲੇਟੈਂਸੀ ਮੁੱਦਿਆਂ ਤੋਂ ਬਚਣ ਦਾ ਇੱਕ ਦਿਲਚਸਪ ਤਰੀਕਾ ਹੈ। ਹਾਲਾਂਕਿ, ਅਸੀਂ ਰਿਡੰਡੈਂਸੀ ਗੁਆਉਣ ਦਾ ਜੋਖਮ ਲੈਂਦੇ ਹਾਂ, ਕਿਉਂਕਿ ISR ਨੂੰ ਸਿਰਫ਼ ਲੀਡਰ ਤੱਕ ਹੀ ਛਾਂਟਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਇਸ ਜੋਖਮ ਤੋਂ ਬਚਣ ਲਈ, ਹੇਠ ਦਿੱਤੀ ਸੰਰਚਨਾ ਦੀ ਵਰਤੋਂ ਕਰੋ: min.insync.replicas.

ਕਲਾਇੰਟ ਕਨੈਕਸ਼ਨ ਦੀ ਗਰੰਟੀ

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

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

ਕਾਫਕਾ ਸਹਿਮਤੀ ਆਰਕੀਟੈਕਚਰ

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

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

ਚਿੜੀਆਘਰ ਕਲੱਸਟਰ ਸਥਿਤੀ ਨੂੰ ਸਟੋਰ ਕਰਦਾ ਹੈ:

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

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

ਉਦਾਹਰਨ ਲਈ, ਦਸ ਭਾਗਾਂ ਅਤੇ 3 ਦੇ ਪ੍ਰਤੀਕ੍ਰਿਤੀ ਕਾਰਕ ਵਾਲੇ ਇੱਕ ਨਵੇਂ ਵਿਸ਼ੇ 'ਤੇ ਵਿਚਾਰ ਕਰੋ। ਕੰਟਰੋਲਰ ਨੂੰ ਹਰੇਕ ਭਾਗ ਲਈ ਇੱਕ ਨੇਤਾ ਚੁਣਨਾ ਚਾਹੀਦਾ ਹੈ, ਦਲਾਲਾਂ ਵਿੱਚ ਨੇਤਾਵਾਂ ਨੂੰ ਅਨੁਕੂਲ ਢੰਗ ਨਾਲ ਵੰਡਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦੇ ਹੋਏ।

ਹਰੇਕ ਸੈਕਸ਼ਨ ਕੰਟਰੋਲਰ ਲਈ:

• ਜ਼ੂਕੀਪਰ ਵਿੱਚ ISR ਅਤੇ ਲੀਡਰ ਬਾਰੇ ਜਾਣਕਾਰੀ ਨੂੰ ਅਪਡੇਟ ਕਰਦਾ ਹੈ;
• ਇਸ ਭਾਗ ਦੀ ਪ੍ਰਤੀਕ੍ਰਿਤੀ ਰੱਖਣ ਵਾਲੇ ਹਰੇਕ ਬ੍ਰੋਕਰ ਨੂੰ ਇੱਕ LeaderAndISRCommand ਭੇਜਦਾ ਹੈ, ਜੋ ਬ੍ਰੋਕਰਾਂ ਨੂੰ ISR ਅਤੇ ਲੀਡਰ ਬਾਰੇ ਸੂਚਿਤ ਕਰਦਾ ਹੈ।

ਜਦੋਂ ਇੱਕ ਦਲਾਲ ਇੱਕ ਲੀਡਰ ਦੇ ਨਾਲ ਅਸਫਲ ਹੋ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਜ਼ੂਕੀਪਰ ਕੰਟਰੋਲਰ ਨੂੰ ਇੱਕ ਸੂਚਨਾ ਭੇਜਦਾ ਹੈ, ਜੋ ਇੱਕ ਨਵਾਂ ਆਗੂ ਚੁਣਦਾ ਹੈ। ਦੁਬਾਰਾ ਫਿਰ, ਕੰਟਰੋਲਰ ਪਹਿਲਾਂ ਜ਼ੂਕੀਪਰ ਨੂੰ ਅੱਪਡੇਟ ਕਰਦਾ ਹੈ ਅਤੇ ਫਿਰ ਹਰੇਕ ਦਲਾਲ ਨੂੰ ਇੱਕ ਕਮਾਂਡ ਭੇਜਦਾ ਹੈ, ਉਹਨਾਂ ਨੂੰ ਲੀਡਰਸ਼ਿਪ ਤਬਦੀਲੀ ਬਾਰੇ ਸੂਚਿਤ ਕਰਦਾ ਹੈ।

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

ਚਿੜੀਆਘਰ ਨੂੰ ਹਮੇਸ਼ਾ ਕਿਸੇ ਵੀ ਤਬਦੀਲੀ ਬਾਰੇ ਸੂਚਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਤਾਂ ਜੋ ਕਿਸੇ ਵਿਘਨ ਦੀ ਸਥਿਤੀ ਵਿੱਚ, ਪ੍ਰਬੰਧਨ ਇੱਕ ਨਵੇਂ ਨੇਤਾ ਵੱਲ ਸੁਚਾਰੂ ਢੰਗ ਨਾਲ ਤਬਦੀਲ ਹੋ ਸਕੇ।

ਚਿੱਤਰ 21. ਕਾਫਕਾ ਸਹਿਮਤੀ

ਪ੍ਰਤੀਕ੍ਰਿਤੀ ਪ੍ਰੋਟੋਕੋਲ

ਪ੍ਰਤੀਕ੍ਰਿਤੀ ਦੇ ਵੇਰਵਿਆਂ ਨੂੰ ਸਮਝਣ ਨਾਲ ਤੁਹਾਨੂੰ ਸੰਭਾਵੀ ਡੇਟਾ ਨੁਕਸਾਨ ਦੇ ਦ੍ਰਿਸ਼ਾਂ ਨੂੰ ਬਿਹਤਰ ਢੰਗ ਨਾਲ ਸਮਝਣ ਵਿੱਚ ਮਦਦ ਮਿਲਦੀ ਹੈ।

ਚੋਣ ਪੁੱਛਗਿੱਛ, ਲੌਗ ਐਂਡ ਆਫਸੈੱਟ (LEO) ਅਤੇ ਹਾਈਵਾਟਰ ਮਾਰਕ (HW)

ਅਸੀਂ ਦੇਖਿਆ ਹੈ ਕਿ ਫਾਲੋਅਰਜ਼ ਸਮੇਂ-ਸਮੇਂ 'ਤੇ ਲੀਡਰ ਨੂੰ ਫੈਚ ਬੇਨਤੀਆਂ ਭੇਜਦੇ ਹਨ। ਡਿਫਾਲਟ ਅੰਤਰਾਲ 500 ms ਹੈ। ਇਹ RabbitMQ ਤੋਂ ਇਸ ਪੱਖੋਂ ਵੱਖਰਾ ਹੈ ਕਿ RabbitMQ ਵਿੱਚ, ਪ੍ਰਤੀਕ੍ਰਿਤੀ ਮਾਸਟਰ ਦੁਆਰਾ ਸ਼ੁਰੂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਕਤਾਰ ਮਿਰਰ ਦੁਆਰਾ ਨਹੀਂ। ਮਾਸਟਰ ਮਿਰਰਾਂ ਵਿੱਚ ਬਦਲਾਅ ਭੇਜਦਾ ਹੈ।

ਲੀਡਰ ਅਤੇ ਸਾਰੇ ਫਾਲੋਅਰ ਇੱਕ ਲੌਗ ਐਂਡ ਆਫਸੈੱਟ (LEO) ਅਤੇ ਇੱਕ ਹਾਈਵਾਟਰ ਮਾਰਕ (HW) ਸਟੋਰ ਕਰਦੇ ਹਨ। LEO ਆਖਰੀ ਸੁਨੇਹੇ ਦੇ ਆਫਸੈੱਟ ਨੂੰ ਸਥਾਨਕ ਪ੍ਰਤੀਕ੍ਰਿਤੀ ਵਿੱਚ ਸਟੋਰ ਕਰਦਾ ਹੈ, ਅਤੇ HW ਆਖਰੀ ਕਮਿਟ ਦੇ ਆਫਸੈੱਟ ਨੂੰ ਸਟੋਰ ਕਰਦਾ ਹੈ। ਯਾਦ ਰੱਖੋ ਕਿ ਕਮਿਟ ਸਥਿਤੀ ਤੱਕ ਪਹੁੰਚਣ ਲਈ, ਸੁਨੇਹਾ ਸਾਰੇ ISR ਪ੍ਰਤੀਕ੍ਰਿਤੀਆਂ ਵਿੱਚ ਸਟੋਰ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ LEO ਆਮ ਤੌਰ 'ਤੇ HW ਤੋਂ ਥੋੜ੍ਹਾ ਅੱਗੇ ਹੁੰਦਾ ਹੈ।

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

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

ਲੀਡਰਸ਼ਿਪ ਦੀ ਅਸਫਲਤਾ

ਜਦੋਂ ਕੋਈ ਲੀਡਰ ਅਸਫਲ ਹੋ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਜ਼ੂਕੀਪਰ ਕੰਟਰੋਲਰ ਨੂੰ ਸੂਚਿਤ ਕਰਦਾ ਹੈ, ਜੋ ਇੱਕ ਨਵੇਂ ਲੀਡਰ ਪ੍ਰਤੀਕ੍ਰਿਤੀ ਦੀ ਚੋਣ ਕਰਦਾ ਹੈ। ਨਵਾਂ ਲੀਡਰ ਆਪਣੇ LEO ਦੇ ਆਧਾਰ 'ਤੇ ਇੱਕ ਨਵਾਂ HW ਨਿਸ਼ਾਨ ਸੈੱਟ ਕਰਦਾ ਹੈ। ਫਿਰ ਫਾਲੋਅਰਜ਼ ਨੂੰ ਨਵੇਂ ਲੀਡਰ ਬਾਰੇ ਜਾਣਕਾਰੀ ਪ੍ਰਾਪਤ ਹੁੰਦੀ ਹੈ। ਕਾਫਕਾ ਸੰਸਕਰਣ ਦੇ ਆਧਾਰ 'ਤੇ, ਇੱਕ ਫਾਲੋਅਰ ਦੋ ਦ੍ਰਿਸ਼ਾਂ ਵਿੱਚੋਂ ਇੱਕ ਦੀ ਚੋਣ ਕਰੇਗਾ:

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

ਇੱਕ ਫਾਲੋਅਰ ਨੂੰ ਹੇਠ ਲਿਖੇ ਕਾਰਨਾਂ ਕਰਕੇ ਲੌਗ ਨੂੰ ਕੱਟਣ ਦੀ ਲੋੜ ਹੋ ਸਕਦੀ ਹੈ:

• ਜਦੋਂ ਕੋਈ ਲੀਡਰ ਅਸਫਲ ਹੋ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਜ਼ੂਕੀਪਰ ਵਿੱਚ ਰਜਿਸਟਰਡ ISR ਸੈੱਟ ਵਿੱਚ ਪਹਿਲਾ ਫਾਲੋਅਰ ਚੋਣ ਜਿੱਤਦਾ ਹੈ ਅਤੇ ਲੀਡਰ ਬਣ ਜਾਂਦਾ ਹੈ। ISR ਦੇ ਸਾਰੇ ਫਾਲੋਅਰਜ਼, ਹਾਲਾਂਕਿ "ਸਮਕਾਲੀ" ਮੰਨੇ ਜਾਂਦੇ ਹਨ, ਹੋ ਸਕਦਾ ਹੈ ਕਿ ਉਨ੍ਹਾਂ ਨੂੰ ਸਾਬਕਾ ਲੀਡਰ ਤੋਂ ਸਾਰੇ ਸੁਨੇਹਿਆਂ ਦੀਆਂ ਕਾਪੀਆਂ ਨਾ ਮਿਲੀਆਂ ਹੋਣ। ਇਹ ਸੰਭਵ ਹੈ ਕਿ ਚੁਣੇ ਹੋਏ ਫਾਲੋਅਰ ਕੋਲ ਸਭ ਤੋਂ ਅੱਪ-ਟੂ-ਡੇਟ ਕਾਪੀ ਨਾ ਹੋਵੇ। ਕਾਫਕਾ ਗਾਰੰਟੀ ਦਿੰਦਾ ਹੈ ਕਿ ਪ੍ਰਤੀਕ੍ਰਿਤੀਆਂ ਵਿਚਕਾਰ ਕੋਈ ਭਿੰਨਤਾ ਨਹੀਂ ਹੈ। ਇਸ ਲਈ, ਭਿੰਨਤਾ ਤੋਂ ਬਚਣ ਲਈ, ਹਰੇਕ ਫਾਲੋਅਰ ਨੂੰ ਆਪਣੀ ਚੋਣ ਦੇ ਸਮੇਂ ਆਪਣੇ ਲੌਗ ਨੂੰ ਨਵੇਂ ਲੀਡਰ ਦੇ HW ਮੁੱਲ ਵਿੱਚ ਕੱਟਣਾ ਚਾਹੀਦਾ ਹੈ। ਇਹ ਇੱਕ ਹੋਰ ਕਾਰਨ ਹੈ ਕਿ ਕੌਂਫਿਗਰੇਸ਼ਨ acks=ਸਾਰੇ ਇਕਸਾਰਤਾ ਲਈ ਬਹੁਤ ਮਹੱਤਵਪੂਰਨ।
• ਸੁਨੇਹੇ ਸਮੇਂ-ਸਮੇਂ 'ਤੇ ਡਿਸਕ 'ਤੇ ਲਿਖੇ ਜਾਂਦੇ ਹਨ। ਜੇਕਰ ਸਾਰੇ ਕਲੱਸਟਰ ਨੋਡ ਇੱਕੋ ਸਮੇਂ ਅਸਫਲ ਹੋ ਜਾਂਦੇ ਹਨ, ਤਾਂ ਵੱਖ-ਵੱਖ ਆਫਸੈੱਟਾਂ ਵਾਲੀਆਂ ਪ੍ਰਤੀਕ੍ਰਿਤੀਆਂ ਡਿਸਕ 'ਤੇ ਸਟੋਰ ਕੀਤੀਆਂ ਜਾਣਗੀਆਂ। ਇਹ ਬਹੁਤ ਸੰਭਵ ਹੈ ਕਿ ਜਦੋਂ ਬ੍ਰੋਕਰ ਵਾਪਸ ਔਨਲਾਈਨ ਆਉਂਦੇ ਹਨ, ਤਾਂ ਚੁਣਿਆ ਗਿਆ ਨਵਾਂ ਨੇਤਾ ਆਪਣੇ ਫਾਲੋਅਰਜ਼ ਦੇ ਪਿੱਛੇ ਹੋਵੇਗਾ ਕਿਉਂਕਿ ਇਹ ਪਹਿਲਾਂ ਡਿਸਕ 'ਤੇ ਲਿਖਿਆ ਗਿਆ ਸੀ।

ਕਲੱਸਟਰ ਵਿੱਚ ਦੁਬਾਰਾ ਸ਼ਾਮਲ ਹੋਣਾ

ਕਲੱਸਟਰ ਵਿੱਚ ਦੁਬਾਰਾ ਸ਼ਾਮਲ ਹੋਣ ਵੇਲੇ, ਪ੍ਰਤੀਕ੍ਰਿਤੀਆਂ ਲੀਡਰ ਫੇਲ੍ਹ ਹੋਣ ਦੇ ਸਮੇਂ ਵਾਂਗ ਹੀ ਵਿਵਹਾਰ ਕਰਦੀਆਂ ਹਨ: ਉਹ ਲੀਡਰ ਦੀ ਪ੍ਰਤੀਕ੍ਰਿਤੀ ਦੀ ਜਾਂਚ ਕਰਦੇ ਹਨ ਅਤੇ ਆਪਣੇ ਲੌਗ ਨੂੰ ਇਸਦੇ HW (ਚੋਣ ਦੇ ਸਮੇਂ) ਵਿੱਚ ਕੱਟਦੇ ਹਨ। ਤੁਲਨਾ ਕਰਕੇ, RabbitMQ ਦੁਬਾਰਾ ਜੁੜੇ ਨੋਡਾਂ ਨੂੰ ਪੂਰੀ ਤਰ੍ਹਾਂ ਨਵੇਂ ਮੰਨਦਾ ਹੈ। ਦੋਵਾਂ ਮਾਮਲਿਆਂ ਵਿੱਚ, ਬ੍ਰੋਕਰ ਕਿਸੇ ਵੀ ਮੌਜੂਦਾ ਸਥਿਤੀ ਨੂੰ ਰੱਦ ਕਰ ਦਿੰਦਾ ਹੈ। ਜੇਕਰ ਆਟੋਮੈਟਿਕ ਸਿੰਕ੍ਰੋਨਾਈਜ਼ੇਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਮਾਸਟਰ ਨੂੰ "ਦੁਨੀਆ ਨੂੰ ਉਡੀਕ ਕਰਨ ਦਿਓ" ਪਹੁੰਚ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਬਿਲਕੁਲ ਸਾਰੇ ਮੌਜੂਦਾ ਸਮੱਗਰੀ ਨੂੰ ਨਵੇਂ ਸ਼ੀਸ਼ੇ ਵਿੱਚ ਦੁਹਰਾਉਣਾ ਚਾਹੀਦਾ ਹੈ। ਇਸ ਕਾਰਵਾਈ ਦੌਰਾਨ, ਮਾਸਟਰ ਕਿਸੇ ਵੀ ਪੜ੍ਹਨ ਜਾਂ ਲਿਖਣ ਦੇ ਕਾਰਜਾਂ ਨੂੰ ਸਵੀਕਾਰ ਨਹੀਂ ਕਰਦਾ ਹੈ। ਇਹ ਪਹੁੰਚ ਵੱਡੀਆਂ ਕਤਾਰਾਂ ਨਾਲ ਸਮੱਸਿਆਵਾਂ ਪੈਦਾ ਕਰਦੀ ਹੈ।

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

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

ਕਨੈਕਟੀਵਿਟੀ ਦਾ ਨੁਕਸਾਨ

ਕਾਫਕਾ ਵਿੱਚ RabbitMQ ਨਾਲੋਂ ਜ਼ਿਆਦਾ ਹਿੱਸੇ ਹਨ, ਇਸ ਲਈ ਜਦੋਂ ਕਲੱਸਟਰ ਕਨੈਕਟੀਵਿਟੀ ਵਿੱਚ ਵਿਘਨ ਪੈਂਦਾ ਹੈ ਤਾਂ ਇਸ ਵਿੱਚ ਵਿਵਹਾਰਾਂ ਦਾ ਇੱਕ ਵਧੇਰੇ ਗੁੰਝਲਦਾਰ ਸਮੂਹ ਹੁੰਦਾ ਹੈ। ਹਾਲਾਂਕਿ, ਕਾਫਕਾ ਨੂੰ ਕਲੱਸਟਰਾਂ ਲਈ ਮੁੱਢ ਤੋਂ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਸੀ, ਇਸ ਲਈ ਇਸਦੇ ਹੱਲ ਬਹੁਤ ਸੋਚ-ਸਮਝ ਕੇ ਤਿਆਰ ਕੀਤੇ ਗਏ ਹਨ।

ਹੇਠਾਂ ਕਨੈਕਟੀਵਿਟੀ ਅਸਫਲਤਾ ਦੇ ਕੁਝ ਦ੍ਰਿਸ਼ ਦਿੱਤੇ ਗਏ ਹਨ:

• ਦ੍ਰਿਸ਼ 1: ਚੇਲਾ ਨੇਤਾ ਨੂੰ ਨਹੀਂ ਦੇਖ ਸਕਦਾ, ਪਰ ਫਿਰ ਵੀ ਚਿੜੀਆਘਰ ਨੂੰ ਦੇਖਦਾ ਹੈ।
• ਦ੍ਰਿਸ਼ 2: ਨੇਤਾ ਕੋਈ ਪੈਰੋਕਾਰ ਨਹੀਂ ਦੇਖਦਾ, ਪਰ ਫਿਰ ਵੀ ਚਿੜੀਆਘਰ ਨੂੰ ਦੇਖਦਾ ਹੈ।
• ਦ੍ਰਿਸ਼ 3. ਚੇਲਾ ਨੇਤਾ ਨੂੰ ਦੇਖਦਾ ਹੈ, ਪਰ ਚਿੜੀਆਘਰ ਨੂੰ ਨਹੀਂ ਦੇਖਦਾ।
• ਦ੍ਰਿਸ਼ਟੀਕੋਣ 4. ਨੇਤਾ ਪੈਰੋਕਾਰਾਂ ਨੂੰ ਦੇਖਦਾ ਹੈ, ਪਰ ਚਿੜੀਆਘਰ ਨੂੰ ਨਹੀਂ ਦੇਖਦਾ।
• ਦ੍ਰਿਸ਼ 5: ਫਾਲੋਅਰ ਦੂਜੇ ਕਾਫਕਾ ਨੋਡਾਂ ਅਤੇ ਚਿੜੀਆਘਰ ਤੋਂ ਪੂਰੀ ਤਰ੍ਹਾਂ ਵੱਖਰਾ ਹੈ।
• ਦ੍ਰਿਸ਼ 6: ਲੀਡਰ ਦੂਜੇ ਕਾਫਕਾ ਨੋਡਾਂ ਅਤੇ ਚਿੜੀਆਘਰ ਤੋਂ ਪੂਰੀ ਤਰ੍ਹਾਂ ਵੱਖਰਾ ਹੈ।
• ਦ੍ਰਿਸ਼ 7: ਕਾਫਕਾ ਕੰਟਰੋਲਰ ਨੋਡ ਇੱਕ ਹੋਰ ਕਾਫਕਾ ਨੋਡ ਨਹੀਂ ਦੇਖਦਾ।
• ਦ੍ਰਿਸ਼ 8। ਕਾਫਕਾ ਕੰਟਰੋਲਰ ਚਿੜੀਆਘਰ ਨੂੰ ਨਹੀਂ ਦੇਖਦਾ।

ਹਰੇਕ ਦ੍ਰਿਸ਼ ਦਾ ਆਪਣਾ ਵਿਵਹਾਰ ਹੁੰਦਾ ਹੈ।

ਦ੍ਰਿਸ਼ 1: ਚੇਲਾ ਨੇਤਾ ਨੂੰ ਨਹੀਂ ਦੇਖ ਸਕਦਾ, ਪਰ ਫਿਰ ਵੀ ਚਿੜੀਆਘਰ ਨੂੰ ਦੇਖਦਾ ਹੈ

ਚਿੱਤਰ 22. ਦ੍ਰਿਸ਼ 1. ਤਿੰਨ ਪ੍ਰਤੀਕ੍ਰਿਤੀਆਂ ਦਾ ISR

ਇੱਕ ਕਨੈਕਸ਼ਨ ਬ੍ਰੇਕ ਬ੍ਰੇਕ 3 ਨੂੰ ਬ੍ਰੋਕਰ 1 ਅਤੇ 2 ਤੋਂ ਵੱਖ ਕਰਦਾ ਹੈ, ਪਰ ਜ਼ੂਕੀਪਰ ਤੋਂ ਨਹੀਂ। ਬ੍ਰੋਕਰ 3 ਹੁਣ ਫੈਚ ਬੇਨਤੀਆਂ ਨਹੀਂ ਭੇਜ ਸਕਦਾ। ਇੱਕ ਸਮਾਂ ਸਮਾਪਤ ਹੋਣ ਤੋਂ ਬਾਅਦ, ਪ੍ਰਤੀਕ੍ਰਿਤੀ.ਲੈਗ.ਟਾਈਮ.ਮੈਕਸ.ਐਮਐਸ ਇਸਨੂੰ ISR ਤੋਂ ਹਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ ਅਤੇ ਸੁਨੇਹਾ ਕਮਿਟ ਵਿੱਚ ਹਿੱਸਾ ਨਹੀਂ ਲੈਂਦਾ। ਇੱਕ ਵਾਰ ਕਨੈਕਟੀਵਿਟੀ ਬਹਾਲ ਹੋਣ ਤੋਂ ਬਾਅਦ, ਇਹ ਬੇਨਤੀਆਂ ਪ੍ਰਾਪਤ ਕਰਨਾ ਦੁਬਾਰਾ ਸ਼ੁਰੂ ਕਰ ਦੇਵੇਗਾ ਅਤੇ ਲੀਡਰ ਨਾਲ ਸੰਪਰਕ ਕਰਨ ਤੋਂ ਬਾਅਦ ISR ਵਿੱਚ ਦੁਬਾਰਾ ਸ਼ਾਮਲ ਹੋ ਜਾਵੇਗਾ। Zookeeper ਨੂੰ ਪਿੰਗ ਪ੍ਰਾਪਤ ਹੁੰਦੇ ਰਹਿਣਗੇ ਅਤੇ ਇਹ ਮੰਨ ਲਵੇਗਾ ਕਿ ਬ੍ਰੋਕਰ ਜ਼ਿੰਦਾ ਅਤੇ ਠੀਕ ਹੈ।

ਚਿੱਤਰ 23. ਸਥਿਤੀ 1. ਜੇਕਰ replica.lag.time.max.ms ਅੰਤਰਾਲ ਦੇ ਅੰਦਰ ਬ੍ਰੋਕਰ ਤੋਂ ਕੋਈ ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਬੇਨਤੀ ਪ੍ਰਾਪਤ ਨਹੀਂ ਹੁੰਦੀ ਹੈ ਤਾਂ ਉਸਨੂੰ ISR ਤੋਂ ਹਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ।

RabbitMQ ਵਾਂਗ, ਕੋਈ ਲਾਜ਼ੀਕਲ ਸਪਲਿਟ-ਬ੍ਰੇਨ ਜਾਂ ਨੋਡ ਸਸਪੈਂਸ਼ਨ ਨਹੀਂ ਹੈ। ਇਸਦੀ ਬਜਾਏ, ਰਿਡੰਡੈਂਸੀ ਘਟਾਈ ਜਾਂਦੀ ਹੈ।

ਦ੍ਰਿਸ਼ 2: ਨੇਤਾ ਕੋਈ ਪੈਰੋਕਾਰ ਨਹੀਂ ਦੇਖਦਾ, ਪਰ ਫਿਰ ਵੀ ਚਿੜੀਆਘਰ ਨੂੰ ਦੇਖਦਾ ਹੈ

ਚਿੱਤਰ 24. ਦ੍ਰਿਸ਼ 2. ਆਗੂ ਅਤੇ ਦੋ ਪੈਰੋਕਾਰ

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

ਚਿੱਤਰ 25. ਦ੍ਰਿਸ਼ 2. ISR ਨੂੰ ਸਿਰਫ਼ ਲੀਡਰ ਤੱਕ ਸੰਕੁਚਿਤ ਕੀਤਾ ਗਿਆ ਹੈ।

ਦ੍ਰਿਸ਼ 3: ਚੇਲਾ ਨੇਤਾ ਨੂੰ ਦੇਖਦਾ ਹੈ ਪਰ ਚਿੜੀਆਘਰ ਦੀ ਦੇਖਭਾਲ ਕਰਨ ਵਾਲੇ ਨੂੰ ਨਹੀਂ।

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

ਚਿੱਤਰ 26. ਸਥਿਤੀ 3. ਫਾਲੋਅਰ ਲੀਡਰ ਨੂੰ ਫੈਚ ਬੇਨਤੀਆਂ ਭੇਜਣਾ ਜਾਰੀ ਰੱਖਦਾ ਹੈ।

ਦ੍ਰਿਸ਼ਟੀਕੋਣ 4: ਨੇਤਾ ਪੈਰੋਕਾਰਾਂ ਨੂੰ ਦੇਖਦਾ ਹੈ ਪਰ ਚਿੜੀਆਘਰ ਨਹੀਂ।

ਚਿੱਤਰ 27. ਦ੍ਰਿਸ਼ 4. ਆਗੂ ਅਤੇ ਦੋ ਪੈਰੋਕਾਰ

ਨੇਤਾ ਜ਼ੂਕੀਪਰ ਤੋਂ ਵੱਖ ਹੁੰਦਾ ਹੈ, ਪਰ ਪੈਰੋਕਾਰਾਂ ਵਾਲੇ ਦਲਾਲਾਂ ਤੋਂ ਨਹੀਂ।

ਚਿੱਤਰ 28. ਦ੍ਰਿਸ਼ 4. ਨੇਤਾ ਚਿੜੀਆਘਰ ਤੋਂ ਅਲੱਗ ਹੈ।

ਕੁਝ ਸਮੇਂ ਬਾਅਦ, ਜ਼ੂਕੀਪਰ ਬ੍ਰੋਕਰ ਦੀ ਅਸਫਲਤਾ ਨੂੰ ਦਰਜ ਕਰੇਗਾ ਅਤੇ ਕੰਟਰੋਲਰ ਨੂੰ ਸੂਚਿਤ ਕਰੇਗਾ। ਕੰਟਰੋਲਰ ਫਿਰ ਫਾਲੋਅਰਜ਼ ਵਿੱਚੋਂ ਇੱਕ ਨਵਾਂ ਲੀਡਰ ਚੁਣੇਗਾ। ਹਾਲਾਂਕਿ, ਅਸਲ ਲੀਡਰ ਇਹ ਮੰਨਣਾ ਜਾਰੀ ਰੱਖੇਗਾ ਕਿ ਇਹ ਲੀਡਰ ਹੈ ਅਤੇ ਐਂਟਰੀਆਂ ਨੂੰ ਸਵੀਕਾਰ ਕਰਨਾ ਜਾਰੀ ਰੱਖੇਗਾ। ਐੱਕਸ=1ਫਾਲੋਅਰ ਹੁਣ ਇਸਨੂੰ ਫੈਚ ਬੇਨਤੀਆਂ ਨਹੀਂ ਭੇਜਦੇ, ਇਸ ਲਈ ਇਹ ਉਹਨਾਂ ਨੂੰ ਮਰਿਆ ਹੋਇਆ ਸਮਝੇਗਾ ਅਤੇ ISR ਨੂੰ ਆਪਣੇ ਆਪ ਵਿੱਚ ਸੰਕੁਚਿਤ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੇਗਾ। ਪਰ ਕਿਉਂਕਿ ਇਸਦਾ Zookeeper ਨਾਲ ਕੋਈ ਸਬੰਧ ਨਹੀਂ ਹੈ, ਇਹ ਅਜਿਹਾ ਨਹੀਂ ਕਰ ਸਕੇਗਾ ਅਤੇ ਉਸ ਸਮੇਂ ਹੋਰ ਪੋਸਟਾਂ ਨੂੰ ਸਵੀਕਾਰ ਕਰਨਾ ਬੰਦ ਕਰ ਦੇਵੇਗਾ।

ਸੁਨੇਹੇ acks=ਸਾਰੇ ਉਹਨਾਂ ਨੂੰ ਰਸੀਦ ਨਹੀਂ ਮਿਲੇਗੀ ਕਿਉਂਕਿ ISR ਵਿੱਚ ਸ਼ੁਰੂ ਵਿੱਚ ਸਾਰੀਆਂ ਪ੍ਰਤੀਕ੍ਰਿਤੀਆਂ ਸ਼ਾਮਲ ਹੁੰਦੀਆਂ ਹਨ, ਪਰ ਸੁਨੇਹੇ ਉਹਨਾਂ ਤੱਕ ਨਹੀਂ ਪਹੁੰਚਦੇ। ਜਦੋਂ ਸ਼ੁਰੂਆਤੀ ਲੀਡਰ ਉਹਨਾਂ ਨੂੰ ISR ਤੋਂ ਹਟਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦਾ ਹੈ, ਤਾਂ ਇਹ ਅਜਿਹਾ ਕਰਨ ਦੇ ਯੋਗ ਨਹੀਂ ਹੋਵੇਗਾ ਅਤੇ ਕਿਸੇ ਵੀ ਸੁਨੇਹੇ ਨੂੰ ਸਵੀਕਾਰ ਕਰਨਾ ਬਿਲਕੁਲ ਬੰਦ ਕਰ ਦੇਵੇਗਾ।

ਕਲਾਇੰਟ ਜਲਦੀ ਹੀ ਲੀਡਰ ਵਿੱਚ ਬਦਲਾਅ ਦੇਖਦੇ ਹਨ ਅਤੇ ਨਵੇਂ ਸਰਵਰ ਨੂੰ ਰਿਕਾਰਡ ਭੇਜਣਾ ਸ਼ੁਰੂ ਕਰ ਦਿੰਦੇ ਹਨ। ਇੱਕ ਵਾਰ ਨੈੱਟਵਰਕ ਰੀਸਟੋਰ ਹੋਣ ਤੋਂ ਬਾਅਦ, ਅਸਲੀ ਲੀਡਰ ਨੂੰ ਅਹਿਸਾਸ ਹੁੰਦਾ ਹੈ ਕਿ ਇਹ ਹੁਣ ਲੀਡਰ ਨਹੀਂ ਰਿਹਾ ਅਤੇ ਆਪਣੇ ਲੌਗ ਨੂੰ HW ਮੁੱਲ ਤੱਕ ਕੱਟ ਦਿੰਦਾ ਹੈ ਜੋ ਲੌਗ ਡਾਇਵਰਜੈਂਸ ਤੋਂ ਬਚਣ ਵਿੱਚ ਅਸਫਲਤਾ ਦੇ ਸਮੇਂ ਨਵੇਂ ਲੀਡਰ ਕੋਲ ਸੀ। ਫਿਰ ਇਹ ਨਵੇਂ ਲੀਡਰ ਨੂੰ ਫੈਚ ਬੇਨਤੀਆਂ ਭੇਜਣਾ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ। ਅਸਲੀ ਲੀਡਰ ਤੋਂ ਸਾਰੇ ਰਿਕਾਰਡ ਜੋ ਨਵੇਂ ਲੀਡਰ ਨੂੰ ਦੁਹਰਾਏ ਨਹੀਂ ਗਏ ਹਨ, ਗੁੰਮ ਹੋ ਜਾਂਦੇ ਹਨ। ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਦੋ ਲੀਡਰਾਂ ਦੇ ਸਰਗਰਮ ਹੋਣ ਦੇ ਕੁਝ ਸਕਿੰਟਾਂ ਦੌਰਾਨ ਮੂਲ ਲੀਡਰ ਦੁਆਰਾ ਸਵੀਕਾਰ ਨਾ ਕੀਤੇ ਗਏ ਸੁਨੇਹੇ ਗੁੰਮ ਹੋ ਜਾਣਗੇ।

ਚਿੱਤਰ 29. ਦ੍ਰਿਸ਼ 4. ਬ੍ਰੋਕਰ 1 'ਤੇ ਲੀਡਰ ਨੈੱਟਵਰਕ ਦੇ ਬਹਾਲ ਹੋਣ ਤੋਂ ਬਾਅਦ ਇੱਕ ਫਾਲੋਅਰ ਬਣ ਜਾਂਦਾ ਹੈ।

ਦ੍ਰਿਸ਼ 5: ਫਾਲੋਅਰ ਦੂਜੇ ਕਾਫਕਾ ਨੋਡਾਂ ਅਤੇ ਚਿੜੀਆਘਰ ਤੋਂ ਪੂਰੀ ਤਰ੍ਹਾਂ ਵੱਖਰਾ ਹੈ।

ਫਾਲੋਅਰ ਨੂੰ ਕਾਫਕਾ ਦੇ ਦੂਜੇ ਨੋਡਾਂ ਅਤੇ ਜ਼ੂਕੀਪਰ ਦੋਵਾਂ ਤੋਂ ਪੂਰੀ ਤਰ੍ਹਾਂ ਅਲੱਗ ਕਰ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। ਇਸਨੂੰ ਨੈੱਟਵਰਕ ਦੇ ਠੀਕ ਹੋਣ ਤੱਕ ISR ਤੋਂ ਹਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਫਿਰ ਦੂਜਿਆਂ ਨਾਲ ਜੁੜ ਜਾਂਦਾ ਹੈ।

ਚਿੱਤਰ 30. ਦ੍ਰਿਸ਼ 5. ਇੱਕ ਅਲੱਗ-ਥਲੱਗ ਫਾਲੋਅਰ ਨੂੰ ISR ਤੋਂ ਹਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ।

ਦ੍ਰਿਸ਼ 6: ਲੀਡਰ ਦੂਜੇ ਕਾਫਕਾ ਨੋਡਾਂ ਅਤੇ ਚਿੜੀਆਘਰ ਤੋਂ ਪੂਰੀ ਤਰ੍ਹਾਂ ਵੱਖਰਾ ਹੈ।

ਚਿੱਤਰ 31. ਦ੍ਰਿਸ਼ 6. ਆਗੂ ਅਤੇ ਦੋ ਪੈਰੋਕਾਰ

ਨੇਤਾ ਆਪਣੇ ਪੈਰੋਕਾਰਾਂ, ਕੰਟਰੋਲਰ ਅਤੇ ਚਿੜੀਆਘਰ ਤੋਂ ਪੂਰੀ ਤਰ੍ਹਾਂ ਅਲੱਗ-ਥਲੱਗ ਹੈ। ਥੋੜ੍ਹੇ ਸਮੇਂ ਲਈ, ਉਹ ਇਹਨਾਂ ਤੋਂ ਪੋਸਟਾਂ ਸਵੀਕਾਰ ਕਰਦੇ ਰਹਿਣਗੇ ਐੱਕਸ=1.

ਚਿੱਤਰ 32. ਦ੍ਰਿਸ਼ 6. ਲੀਡਰ ਨੂੰ ਹੋਰ ਕਾਫਕਾ ਅਤੇ ਚਿੜੀਆਘਰ ਨੋਡਾਂ ਤੋਂ ਅਲੱਗ ਕਰਨਾ

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

ਇਸ ਦੌਰਾਨ, ਚਿੜੀਆਘਰ ਅਲੱਗ-ਥਲੱਗ ਕੀਤੇ ਬ੍ਰੋਕਰ ਨੂੰ ਮ੍ਰਿਤਕ ਵਜੋਂ ਚਿੰਨ੍ਹਿਤ ਕਰੇਗਾ, ਅਤੇ ਕੰਟਰੋਲਰ ਇੱਕ ਨਵਾਂ ਨੇਤਾ ਚੁਣੇਗਾ।

ਚਿੱਤਰ 33. ਦ੍ਰਿਸ਼ 6. ਦੋ ਆਗੂ

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

ਚਿੱਤਰ 34. ਸਥਿਤੀ 6. ਨਿਰਮਾਤਾ ਇੱਕ ਨਵੇਂ ਲੀਡਰ ਵੱਲ ਜਾਂਦੇ ਹਨ

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

ਚਿੱਤਰ 35. ਦ੍ਰਿਸ਼ 6. ਨੈੱਟਵਰਕ ਕਨੈਕਟੀਵਿਟੀ ਬਹਾਲ ਹੋਣ ਤੋਂ ਬਾਅਦ ਅਸਲੀ ਆਗੂ ਇੱਕ ਫਾਲੋਅਰ ਬਣ ਜਾਂਦਾ ਹੈ।

ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਥੋੜ੍ਹੇ ਸਮੇਂ ਲਈ ਇੱਕ ਤਰਕਪੂਰਨ ਵਿਛੋੜਾ ਦੇਖਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਪਰ ਸਿਰਫ ਤਾਂ ਹੀ ਜੇਕਰ ਐੱਕਸ=1 и min.insync.replicas ਨਾਲ ਹੀ 1. ਨੈੱਟਵਰਕ ਰੀਸਟੋਰ ਹੋਣ ਤੋਂ ਬਾਅਦ, ਜਦੋਂ ਅਸਲੀ ਲੀਡਰ ਨੂੰ ਅਹਿਸਾਸ ਹੁੰਦਾ ਹੈ ਕਿ ਇਹ ਹੁਣ ਲੀਡਰ ਨਹੀਂ ਰਿਹਾ, ਜਾਂ ਜਦੋਂ ਸਾਰੇ ਕਲਾਇੰਟ ਇਹ ਮਹਿਸੂਸ ਕਰਦੇ ਹਨ ਕਿ ਲੀਡਰ ਬਦਲ ਗਿਆ ਹੈ ਅਤੇ ਨਵੇਂ ਲੀਡਰ ਨੂੰ ਲਿਖਣਾ ਸ਼ੁਰੂ ਕਰ ਦਿੰਦੇ ਹਨ - ਜੋ ਵੀ ਪਹਿਲਾਂ ਆਵੇ। ਦੋਵਾਂ ਮਾਮਲਿਆਂ ਵਿੱਚ, ਕੁਝ ਸੁਨੇਹਾ ਗੁਆਚ ਜਾਵੇਗਾ, ਪਰ ਸਿਰਫ ਐੱਕਸ=1.

ਇਸ ਦ੍ਰਿਸ਼ਟੀਕੋਣ ਦਾ ਇੱਕ ਹੋਰ ਰੂਪ ਉਦੋਂ ਵਾਪਰਦਾ ਹੈ ਜਦੋਂ, ਨੈੱਟਵਰਕ ਦੇ ਵੰਡ ਤੋਂ ਠੀਕ ਪਹਿਲਾਂ, ਫਾਲੋਅਰ ਪਿੱਛੇ ਰਹਿ ਜਾਂਦੇ ਹਨ, ਅਤੇ ਲੀਡਰ ISR ਨੂੰ ਸਿਰਫ਼ ਆਪਣੇ ਆਪ ਵਿੱਚ ਸੁੰਗੜ ਜਾਂਦਾ ਹੈ। ਫਿਰ ਇਹ ਕਨੈਕਟੀਵਿਟੀ ਦੇ ਨੁਕਸਾਨ ਕਾਰਨ ਅਲੱਗ-ਥਲੱਗ ਹੋ ਜਾਂਦਾ ਹੈ। ਇੱਕ ਨਵਾਂ ਨੇਤਾ ਚੁਣਿਆ ਜਾਂਦਾ ਹੈ, ਪਰ ਅਸਲ ਨੇਤਾ ਲਿਖਤਾਂ ਨੂੰ ਸਵੀਕਾਰ ਕਰਨਾ ਜਾਰੀ ਰੱਖਦਾ ਹੈ, ਭਾਵੇਂ acks=ਸਾਰੇ, ਕਿਉਂਕਿ ISR ਵਿੱਚ ਕੋਈ ਹੋਰ ਨਹੀਂ ਹੈ। ਨੈੱਟਵਰਕ ਰੀਸਟੋਰ ਹੋਣ ਤੋਂ ਬਾਅਦ ਇਹ ਰਿਕਾਰਡ ਗੁੰਮ ਹੋ ਜਾਣਗੇ। ਇਸ ਤੋਂ ਬਚਣ ਦਾ ਇੱਕੋ ਇੱਕ ਤਰੀਕਾ ਹੈ ਘੱਟੋ-ਘੱਟ.ਇਨਸਿੰਕ.ਪ੍ਰਤੀਕ੍ਰਿਤੀਆਂ = 2.

ਦ੍ਰਿਸ਼ 7: ਕਾਫਕਾ ਕੰਟਰੋਲਰ ਨੋਡ ਇੱਕ ਹੋਰ ਕਾਫਕਾ ਨੋਡ ਨਹੀਂ ਦੇਖਦਾ।

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

ਦ੍ਰਿਸ਼ 8। ਕਾਫਕਾ ਕੰਟਰੋਲਰ ਚਿੜੀਆਘਰ ਨੂੰ ਨਹੀਂ ਦੇਖਦਾ।

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

ਦ੍ਰਿਸ਼ਾਂ ਤੋਂ ਸਿੱਟੇ

ਅਸੀਂ ਦੇਖਦੇ ਹਾਂ ਕਿ ਫਾਲੋਅਰ ਕਨੈਕਟੀਵਿਟੀ ਦੇ ਨੁਕਸਾਨ ਦੇ ਨਤੀਜੇ ਵਜੋਂ ਸੁਨੇਹਾ ਨਹੀਂ ਜਾਂਦਾ, ਪਰ ਨੈੱਟਵਰਕ ਦੇ ਠੀਕ ਹੋਣ ਤੱਕ ਸਿਰਫ਼ ਅਸਥਾਈ ਤੌਰ 'ਤੇ ਰਿਡੰਡੈਂਸੀ ਨੂੰ ਘਟਾਉਂਦਾ ਹੈ। ਇਹ, ਬੇਸ਼ੱਕ, ਜੇਕਰ ਇੱਕ ਜਾਂ ਵੱਧ ਨੋਡ ਗੁੰਮ ਹੋ ਜਾਂਦੇ ਹਨ ਤਾਂ ਡੇਟਾ ਦਾ ਨੁਕਸਾਨ ਹੋ ਸਕਦਾ ਹੈ।

ਜੇਕਰ ਲੀਡਰ ਕਨੈਕਟੀਵਿਟੀ ਦੇ ਨੁਕਸਾਨ ਕਾਰਨ ਜ਼ੂਕੀਪਰ ਤੋਂ ਵੱਖ ਹੋ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇਸ ਦੇ ਨਤੀਜੇ ਵਜੋਂ ਸੁਨੇਹੇ ਗੁੰਮ ਹੋ ਸਕਦੇ ਹਨ ਐੱਕਸ=1ਜ਼ੂਕੀਪਰ ਨਾਲ ਸੰਪਰਕ ਦੀ ਘਾਟ ਦੋ ਲੀਡਰਾਂ ਨਾਲ ਥੋੜ੍ਹੇ ਸਮੇਂ ਲਈ ਲਾਜ਼ੀਕਲ ਫੁੱਟ ਦਾ ਕਾਰਨ ਬਣਦੀ ਹੈ। ਇਹ ਸਮੱਸਿਆ ਪੈਰਾਮੀਟਰ ਦੁਆਰਾ ਹੱਲ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। acks=ਸਾਰੇ.

ਪੈਰਾਮੀਟਰ min.insync.replicas ਦੋ ਜਾਂ ਦੋ ਤੋਂ ਵੱਧ ਪ੍ਰਤੀਕ੍ਰਿਤੀਆਂ ਵਿੱਚ ਵਾਧੂ ਗਾਰੰਟੀ ਮਿਲਦੀ ਹੈ ਕਿ ਅਜਿਹੇ ਥੋੜ੍ਹੇ ਸਮੇਂ ਦੇ ਦ੍ਰਿਸ਼ਾਂ ਦੇ ਨਤੀਜੇ ਵਜੋਂ ਸੁਨੇਹਾ ਨਹੀਂ ਗੁਆਚੇਗਾ, ਜਿਵੇਂ ਕਿ ਦ੍ਰਿਸ਼ 6 ਵਿੱਚ ਹੈ।

ਸੁਨੇਹੇ ਦੇ ਨੁਕਸਾਨ ਦਾ ਸਾਰ

ਆਓ ਕਾਫਕਾ ਵਿੱਚ ਡੇਟਾ ਗੁਆਉਣ ਦੇ ਸਾਰੇ ਤਰੀਕਿਆਂ ਦੀ ਸੂਚੀ ਬਣਾਈਏ:

• ਜੇਕਰ ਸੁਨੇਹਿਆਂ ਨੂੰ ਵਰਤ ਕੇ ਸਵੀਕਾਰ ਕੀਤਾ ਗਿਆ ਸੀ ਤਾਂ ਕਿਸੇ ਵੀ ਨੇਤਾ ਦੀ ਅਸਫਲਤਾ ਐੱਕਸ=1
• ਲੀਡਰਸ਼ਿਪ ਦਾ ਕੋਈ ਵੀ ਅਸ਼ੁੱਧ ਤਬਾਦਲਾ, ਭਾਵ ISR ਤੋਂ ਬਾਹਰ ਕਿਸੇ ਅਨੁਯਾਈ ਨੂੰ, ਭਾਵੇਂ acks=ਸਾਰੇ
• ਜੇਕਰ ਸੁਨੇਹਿਆਂ ਦੀ ਪੁਸ਼ਟੀ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਤਾਂ ਜ਼ੂਕੀਪਰ ਤੋਂ ਲੀਡਰ ਨੂੰ ਅਲੱਗ ਕਰੋ ਐੱਕਸ=1
• ਨੇਤਾ ਦਾ ਪੂਰੀ ਤਰ੍ਹਾਂ ਅਲੱਗ-ਥਲੱਗ ਹੋਣਾ, ਜਿਸਨੇ ਪਹਿਲਾਂ ਹੀ ISR ਸਮੂਹ ਨੂੰ ਆਪਣੇ ਵੱਲ ਸੰਕੁਚਿਤ ਕਰ ਲਿਆ ਹੈ। ਸਾਰੇ ਸੰਚਾਰ ਖਤਮ ਹੋ ਜਾਣਗੇ, ਇੱਥੋਂ ਤੱਕ ਕਿ acks=ਸਾਰੇਇਹ ਤਾਂ ਹੀ ਸੱਚ ਹੈ ਜੇਕਰ ਘੱਟੋ-ਘੱਟ.ਇਨਸਿੰਕ.ਪ੍ਰਤੀਕ੍ਰਿਤੀਆਂ=1.
• ਸਾਰੇ ਪਾਰਟੀਸ਼ਨ ਨੋਡਾਂ ਦੀਆਂ ਇੱਕੋ ਸਮੇਂ ਅਸਫਲਤਾਵਾਂ। ਕਿਉਂਕਿ ਸੁਨੇਹੇ ਮੈਮੋਰੀ ਤੋਂ ਸਵੀਕਾਰ ਕੀਤੇ ਜਾਂਦੇ ਹਨ, ਕੁਝ ਅਜੇ ਡਿਸਕ ਤੇ ਨਹੀਂ ਲਿਖੇ ਜਾ ਸਕਦੇ ਹਨ। ਸਰਵਰ ਰੀਬੂਟ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਕੁਝ ਸੁਨੇਹੇ ਗੁੰਮ ਹੋ ਸਕਦੇ ਹਨ।

ਅਸਪਸ਼ਟ ਲੀਡਰਸ਼ਿਪ ਤਬਦੀਲੀਆਂ ਨੂੰ ਜਾਂ ਤਾਂ ਉਹਨਾਂ ਨੂੰ ਰੋਕ ਕੇ ਜਾਂ ਘੱਟੋ-ਘੱਟ ਦੋ ਦੀ ਰਿਡੰਡੈਂਸੀ ਨੂੰ ਯਕੀਨੀ ਬਣਾ ਕੇ ਟਾਲਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਸਭ ਤੋਂ ਮਜ਼ਬੂਤ ​​ਸੰਰਚਨਾ ਇੱਕ ਸੁਮੇਲ ਹੈ acks=ਸਾਰੇ и min.insync.replicas 1 ਤੋਂ ਵੱਧ।

RabbitMQ ਅਤੇ Kafka ਦੀ ਭਰੋਸੇਯੋਗਤਾ ਦੀ ਸਿੱਧੀ ਤੁਲਨਾ

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

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

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

• ਹਰ ਕੁਝ ਸੌ ਮਿਲੀਸਕਿੰਟਾਂ ਵਿੱਚ fsync
• ਮਿਰਰ ਅਸਫਲਤਾ ਦਾ ਪਤਾ ਸਿਰਫ਼ ਉਹਨਾਂ ਪੈਕੇਟਾਂ ਦੇ ਟਾਈਮ-ਟੂ-ਲਾਈਵ ਤੋਂ ਬਾਅਦ ਹੀ ਲਗਾਇਆ ਜਾ ਸਕਦਾ ਹੈ ਜੋ ਹਰੇਕ ਨੋਡ (ਨੈੱਟ ਟਿੱਕ) ਦੀ ਉਪਲਬਧਤਾ ਦੀ ਜਾਂਚ ਕਰਦੇ ਹਨ। ਜੇਕਰ ਮਿਰਰ ਹੌਲੀ ਜਾਂ ਘੱਟ ਹੈ, ਤਾਂ ਇਹ ਲੇਟੈਂਸੀ ਜੋੜਦਾ ਹੈ।

ਕਾਫਕਾ ਇਸ ਤੱਥ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ ਕਿ ਜੇਕਰ ਕੋਈ ਸੁਨੇਹਾ ਕਈ ਨੋਡਾਂ ਵਿੱਚ ਸਟੋਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇਹ ਸੁਨੇਹੇ ਯਾਦ ਵਿੱਚ ਹੁੰਦੇ ਹੀ ਪਛਾਣ ਸਕਦਾ ਹੈ। ਇਹ ਕਿਸੇ ਵੀ ਕਿਸਮ ਦੇ ਸੁਨੇਹੇ ਗੁਆਉਣ ਦਾ ਜੋਖਮ ਪੇਸ਼ ਕਰਦਾ ਹੈ (ਭਾਵੇਂ acks=ਸਾਰੇ, ਘੱਟੋ-ਘੱਟ.ਇਨਸਿੰਕ.ਪ੍ਰਤੀਕ੍ਰਿਤੀਆਂ=2) ਇੱਕੋ ਸਮੇਂ ਇਨਕਾਰ ਕਰਨ ਦੀ ਸਥਿਤੀ ਵਿੱਚ।

ਕੁੱਲ ਮਿਲਾ ਕੇ, ਕਾਫਕਾ ਵਧੀਆ ਪ੍ਰਦਰਸ਼ਨ ਦਰਸਾਉਂਦਾ ਹੈ ਅਤੇ ਇਸਨੂੰ ਕਲੱਸਟਰਾਂ ਲਈ ਮੁੱਢ ਤੋਂ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਹੈ। ਭਰੋਸੇਯੋਗਤਾ ਲਈ ਜੇਕਰ ਲੋੜ ਹੋਵੇ ਤਾਂ ਫਾਲੋਅਰਜ਼ ਦੀ ਗਿਣਤੀ 11 ਤੱਕ ਵਧਾਈ ਜਾ ਸਕਦੀ ਹੈ। ਪ੍ਰਤੀਕ੍ਰਿਤੀ ਕਾਰਕ 5 ਹੈ, ਅਤੇ ਸਿੰਕ ਵਿੱਚ ਪ੍ਰਤੀਕ੍ਰਿਤੀਆਂ ਦੀ ਘੱਟੋ-ਘੱਟ ਗਿਣਤੀ 1 ਹੈ। ਘੱਟੋ-ਘੱਟ.ਇਨਸਿੰਕ.ਪ੍ਰਤੀਕ੍ਰਿਤੀਆਂ=3 ਸੁਨੇਹਾ ਗੁਆਉਣਾ ਇੱਕ ਬਹੁਤ ਹੀ ਦੁਰਲੱਭ ਘਟਨਾ ਬਣਾ ਦੇਵੇਗਾ। ਜੇਕਰ ਤੁਹਾਡਾ ਬੁਨਿਆਦੀ ਢਾਂਚਾ ਇਸ ਪ੍ਰਤੀਕ੍ਰਿਤੀ ਕਾਰਕ ਅਤੇ ਰਿਡੰਡੈਂਸੀ ਦੇ ਪੱਧਰ ਦਾ ਸਮਰਥਨ ਕਰ ਸਕਦਾ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਇਸ ਵਿਕਲਪ ਨੂੰ ਚੁਣ ਸਕਦੇ ਹੋ।

RabbitMQ ਕਲੱਸਟਰਿੰਗ ਛੋਟੀਆਂ ਕਤਾਰਾਂ ਲਈ ਵਧੀਆ ਹੈ। ਹਾਲਾਂਕਿ, ਭਾਰੀ ਟ੍ਰੈਫਿਕ ਦੇ ਅਧੀਨ ਛੋਟੀਆਂ ਕਤਾਰਾਂ ਵੀ ਤੇਜ਼ੀ ਨਾਲ ਵਧ ਸਕਦੀਆਂ ਹਨ। ਜਿਵੇਂ-ਜਿਵੇਂ ਕਤਾਰਾਂ ਵੱਡੀਆਂ ਹੁੰਦੀਆਂ ਜਾਂਦੀਆਂ ਹਨ, ਉਪਲਬਧਤਾ ਅਤੇ ਭਰੋਸੇਯੋਗਤਾ ਵਿਚਕਾਰ ਇੱਕ ਸਪੱਸ਼ਟ ਵਪਾਰ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। RabbitMQ ਕਲੱਸਟਰਿੰਗ ਘੱਟ ਆਮ ਦ੍ਰਿਸ਼ਾਂ ਲਈ ਸਭ ਤੋਂ ਵਧੀਆ ਹੈ, ਜਿੱਥੇ RabbitMQ ਦੀ ਲਚਕਤਾ ਦੇ ਫਾਇਦੇ ਕਲੱਸਟਰਿੰਗ ਦੀਆਂ ਕਿਸੇ ਵੀ ਕਮੀਆਂ ਤੋਂ ਵੱਧ ਹਨ।

ਵੱਡੀਆਂ ਕਤਾਰਾਂ ਪ੍ਰਤੀ RabbitMQ ਦੀ ਕਮਜ਼ੋਰੀ ਦਾ ਇੱਕ ਇਲਾਜ ਉਹਨਾਂ ਨੂੰ ਕਈ ਛੋਟੀਆਂ ਕਤਾਰਾਂ ਵਿੱਚ ਵੰਡਣਾ ਹੈ। ਜੇਕਰ ਤੁਹਾਨੂੰ ਪੂਰੀ ਕਤਾਰ ਦੇ ਪੂਰੇ ਆਰਡਰਿੰਗ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ, ਪਰ ਸਿਰਫ਼ ਸੰਬੰਧਿਤ ਸੁਨੇਹਿਆਂ (ਉਦਾਹਰਣ ਵਜੋਂ, ਕਿਸੇ ਖਾਸ ਕਲਾਇੰਟ ਤੋਂ ਸੁਨੇਹੇ) ਦੀ ਲੋੜ ਹੈ, ਜਾਂ ਬਿਲਕੁਲ ਵੀ ਆਰਡਰਿੰਗ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ, ਤਾਂ ਇਹ ਤਰੀਕਾ ਸਵੀਕਾਰਯੋਗ ਹੈ: ਮੇਰਾ ਪ੍ਰੋਜੈਕਟ ਵੇਖੋ। ਰੀਬੈਲੈਂਸਰ ਕਤਾਰ ਨੂੰ ਵੰਡਣ ਲਈ (ਪ੍ਰੋਜੈਕਟ ਅਜੇ ਵੀ ਸ਼ੁਰੂਆਤੀ ਪੜਾਵਾਂ ਵਿੱਚ ਹੈ)।

ਅੰਤ ਵਿੱਚ, RabbitMQ ਅਤੇ Kafka ਦੋਵਾਂ ਦੇ ਕਲੱਸਟਰਿੰਗ ਅਤੇ ਪ੍ਰਤੀਕ੍ਰਿਤੀ ਵਿਧੀਆਂ ਵਿੱਚ ਕਈ ਬੱਗਾਂ ਬਾਰੇ ਨਾ ਭੁੱਲੋ। ਸਮੇਂ ਦੇ ਨਾਲ, ਸਿਸਟਮ ਵਧੇਰੇ ਪਰਿਪੱਕ ਅਤੇ ਸਥਿਰ ਹੋ ਗਏ ਹਨ, ਪਰ ਕੋਈ ਵੀ ਸੁਨੇਹਾ ਕਦੇ ਵੀ ਨੁਕਸਾਨ ਤੋਂ 100% ਸੁਰੱਖਿਅਤ ਨਹੀਂ ਹੋਵੇਗਾ! ਇਸ ਤੋਂ ਇਲਾਵਾ, ਡੇਟਾ ਸੈਂਟਰਾਂ ਵਿੱਚ ਵੱਡੇ ਪੱਧਰ 'ਤੇ ਆਫ਼ਤਾਂ ਵਾਪਰਦੀਆਂ ਹਨ!

ਜੇਕਰ ਮੈਂ ਕੁਝ ਖੁੰਝ ਗਿਆ ਹਾਂ, ਕੋਈ ਗਲਤੀ ਕੀਤੀ ਹੈ, ਜਾਂ ਤੁਸੀਂ ਕਿਸੇ ਵੀ ਨੁਕਤੇ ਨਾਲ ਅਸਹਿਮਤ ਹੋ, ਤਾਂ ਕਿਰਪਾ ਕਰਕੇ ਬਿਨਾਂ ਝਿਜਕ ਟਿੱਪਣੀ ਕਰੋ ਜਾਂ ਮੇਰੇ ਨਾਲ ਸੰਪਰਕ ਕਰੋ।

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

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

ਮੈਨੂੰ ਹੋਰ ਤਕਨਾਲੋਜੀਆਂ ਦਿਖਾਈ ਦਿੰਦੀਆਂ ਹਨ ਜਿਨ੍ਹਾਂ ਵਿੱਚ ਇਸ ਭਰੋਸੇਯੋਗਤਾ ਅਤੇ ਗਾਰੰਟੀਸ਼ੁਦਾ ਆਰਡਰਿੰਗ ਦੀ ਘਾਟ ਹੈ, ਫਿਰ ਮੈਂ RabbitMQ ਅਤੇ Kafka ਨੂੰ ਵੇਖਦਾ ਹਾਂ ਅਤੇ ਮੈਨੂੰ ਇਹਨਾਂ ਦੋਵਾਂ ਪ੍ਰਣਾਲੀਆਂ ਵਿੱਚ ਅਵਿਸ਼ਵਾਸ਼ਯੋਗ ਮੁੱਲ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ।

ਸਰੋਤ: www.habr.com