Laravel 13.31 interruptible jobs ਜੋੜਦਾ ਹੈ, ਜੋ queue workers ਨੂੰ ਡਿਪਲਾਈਮੈਂਟਸ ਦੌਰਾਨ ਭੇਜੇ ਗਏ SIGTERM ਸਿਗਨਲ ਨੂੰ ਫੜਨ ਅਤੇ ਕਿਸੇ ਕੰਮ ਨੂੰ ਅੱਧ ਵਿਚਕਾਰ ਰੋਕਣ ਦੀ ਬਜਾਏ ਸਾਫ਼ ਤਰੀਕੇ ਨਾਲ ਬੰਦ ਹੋਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ। ਉਹ ਟੀਮਾਂ ਜੋ ਲੰਬੇ jobs ਚਲਾਉਂਦੀਆਂ ਹਨ—ਜਿਵੇਂ ਕਿ ਹਜ਼ਾਰਾਂ ਰੋਅ (rows) ਨੂੰ ਪ੍ਰੋਸੈਸ ਕਰਨਾ, ਬਲਕ ਈਮੇਲ ਭੇਜਣਾ, ਜਾਂ ਰਿਪੋਰਟਾਂ ਤਿਆਰ ਕਰਨਾ—ਉਨ੍ਹਾਂ ਨੂੰ ਫਾਇਦਾ ਹੁੰਦਾ ਹੈ ਕਿਉਂਕਿ ਨਵਾਂ ਰੀਲੀਜ਼ ਆਉਣ ਵੇਲੇ ਡਾਟਾ ਸਹੀ (consistent) ਰਹਿੰਦਾ ਹੈ।
ਡਿਪਲਾਈਮੈਂਟਸ ਕਾਰਨ jobs ਕਿਉਂ ਖ਼ਤਮ ਹੋ ਰਹੇ ਹਨ
ਜਦੋਂ ਕੋਈ ਨਵਾਂ ਵਰਜ਼ਨ ਆਉਂਦਾ ਹੈ, ਤਾਂ Supervisor, Docker, ਅਤੇ Kubernetes ਵਰਗੇ process managers ਮੌਜੂਦਾ workers ਨੂੰ SIGTERM ਭੇਜ ਕੇ ਰੋਕਣ ਲਈ ਕਹਿੰਦੇ ਹਨ, ਜੋ ਕਿ ਬੰਦ ਕਰਨ ਲਈ ਇੱਕ ਨਿਮਰਤਾਪੂਰਵਕ ਬੇਨਤੀ ਹੈ। ਜ਼ਿਆਦਾਤਰ workers ਬਾਹਰ ਨਿਕਲਣ ਤੋਂ ਪਹਿਲਾਂ ਮੌਜੂਦਾ job ਦੇ ਖਤਮ ਹੋਣ ਦੀ ਉਡੀਕ ਕਰਦੇ ਹਨ। ਸਮੱਸਿਆ ਉਦੋਂ ਆਉਂਦੀ ਹੈ ਜਦੋਂ ਮੈਨੇਜਰ ਪਾਲਣਾ ਕਰਨ ਲਈ ਸਿਰਫ਼ ਕੁਝ ਹੀ ਸਕਿੰਟਾਂ ਦਾ ਸਮਾਂ ਦਿੰਦਾ ਹੈ। ਜੇਕਰ ਕਿਸੇ job ਨੂੰ ਮਿੰਟਾਂ ਦੀ ਲੋੜ ਹੈ, ਤਾਂ ਮੈਨੇਜਰ SIGKILL ਵੱਲ ਵਧ ਜਾਂਦਾ ਹੈ, ਜੋ ਪ੍ਰੋਸੈਸ ਨੂੰ ਤੁਰੰਤ ਖ਼ਤਮ ਕਰ ਦਿੰਦਾ ਹੈ। Job ਕਦੇ ਵੀ ਇੱਕ ਸਹੀ (consistent) ਸਥਿਤੀ ਤੱਕ ਨਹੀਂ ਪਹੁੰਚ ਪਾਉਂਦੀ, ਜਿਸ ਨਾਲ ਅਧੂਰੇ ਅਪਡੇਟ ਕੀਤੇ ਰਿਕਾਰਡ, ਲਾਵਾਰਿਸ (orphaned) ਫਾਈਲਾਂ, ਜਾਂ ਡੁਪਲੀਕੇਟ ਕੰਮ ਰਹਿ ਜਾਂਦੇ ਹਨ।
Laravel ਦਾ ਜਵਾਬ: cooperative interruption
Laravel 13.31 ਇੱਕ Interruptible ਨਾਮ ਦਾ contract ਪੇਸ਼ ਕਰਦਾ ਹੈ ਜਿਸ ਨੂੰ ਇੱਕ job class termination request ਤੋਂ ਜਾਣੂ ਹੋਣ ਲਈ ਲਾਗੂ (implement) ਕਰ ਸਕਦੀ ਹੈ। ਜਦੋਂ SIGTERM ਆਉਂਦਾ ਹੈ, ਤਾਂ Laravel job ਦੇ interrupted() method ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ। ਫਰੇਮਵਰਕ job ਨੂੰ ਆਪਣੇ ਆਪ ਰੋਕਦਾ ਨਹੀਂ ਹੈ; job ਨੂੰ ਉਸ flag ਦੀ ਜਾਂਚ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ ਜੋ Laravel ਸੈੱਟ ਕਰਦਾ ਹੈ ਅਤੇ ਆਪਣੇ ਆਪ ਬਾਹਰ ਨਿਕਲਣਾ ਚਾਹੀਦਾ ਹੈ। ਇਹ cooperative ਮਾਡਲ ਡਿਵੈਲਪਰਾਂ ਨੂੰ ਮੌਜੂਦਾ ਲੂਪ (loop) ਨੂੰ ਖਤਮ ਕਰਨ, ਅਧੂਰੇ ਬਦਲਾਅ ਵਾਪਸ ਲੈਣ (roll back), ਜਾਂ ਬਾਹਰ ਨਿਕਲਣ ਤੋਂ ਪਹਿਲਾਂ ਇੱਕ ਚੈੱਕਪੁਆਇੰਟ ਲਿਖਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ।
ਕਿਸੇ job ਨੂੰ interruptible ਕਿਵੇਂ ਬਣਾਇਆ ਜਾਵੇ
- Contract ਨੂੰ ਲਾਗੂ ਕਰੋ – job class definition ਵਿੱਚ
implements Interruptibleਜੋੜੋ। - Work loop ਦੇ ਅੰਦਰ flag ਦੀ ਜਾਂਚ ਕਰੋ – ਹਰ iteration ਵਿੱਚ ਇਹ ਦੇਖਣ ਲਈ ਇੱਕ ਚੈੱਕ ਪਾਓ ਕਿ ਕੀ job ਨੂੰ ਰੁਕਣਾ ਚਾਹੀਦਾ ਹੈ।
- Cleanup ਕਰੋ –
interrupted()ਵਿੱਚ, ਕੋਈ ਵੀ ਅਜਿਹੀ ਸਥਿਤੀ (state) ਸੁਰੱਖਿਅਤ ਕਰੋ ਜੋ job ਨੂੰ ਬਾਅਦ ਵਿੱਚ ਦੁਬਾਰਾ ਸ਼ੁਰੂ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦੇਵੇ, ਜਾਂ ਬਾਅਦ ਦੇ ਵਿਸ਼ਲੇਸ਼ਣ ਲਈ interruption ਨੂੰ log ਕਰੋ।
ਸਭ ਤੋਂ ਵੱਡੀ ਜਾਲ: --once ਦੀ ਵਰਤੋਂ ਨਾ ਕਰੋ
php artisan queue:work --once ਨਾਲ queue worker ਚਲਾਉਣ ਨਾਲ signal handling ਪੂਰੀ ਤਰ੍ਹਾਂ ਅਯੋਗ ਹੋ ਜਾਂਦੀ ਹੈ। Worker ਇੱਕ ਸਿੰਗਲ job ਨੂੰ ਪ੍ਰੋਸੈਸ ਕਰਦਾ ਹੈ ਅਤੇ ਬਾਹਰ ਨਿਕਲ ਜਾਂਦਾ ਹੈ, ਪਰ ਇਹ ਕਦੇ ਵੀ SIGTERM handler ਨੂੰ ਰਜਿਸਟਰ ਨਹੀਂ ਕਰਦਾ। ਨਤੀਜੇ ਵਜੋਂ, ਕੋਈ ਵੀ interruptible job termination request ਨੂੰ ਨਜ਼ਰਅੰਦਾਜ਼ ਕਰ ਦਿੰਦੀ ਹੈ ਅਤੇ ਪ੍ਰੋਸੈਸ ਦੇ ਵਿਚਕਾਰ ਹੀ ਖ਼ਤਮ ਹੋ ਜਾਂਦੀ ਹੈ। ਇਹ ਪੈਟਰਨ cron-driven ਕੰਟੇਨਰਾਂ ਅਤੇ one-shot ਡਿਪਲਾਈਮੈਂਟਸ ਵਿੱਚ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ। ਜਦੋਂ ਵੀ ਤੁਹਾਨੂੰ interruptible jobs ਦੀ ਲੋੜ ਹੋਵੇ, ਤਾਂ daemon mode (php artisan queue:work) ਚਲਾ ਕੇ ਇਸ ਨੂੰ ਠੀਕ ਕਰੋ।
Interruptions 'ਤੇ ਨਜ਼ਰ ਰੱਖਣਾ
Laravel ਦੋ events ਫਾਇਰ ਕਰਦਾ ਹੈ ਜਿਨ੍ਹਾਂ ਵਿੱਚ ਤੁਸੀਂ ਹੁੱਕ (hook) ਕਰ ਸਕਦੇ ਹੋ:
- WorkerInterrupted – ਜਦੋਂ ਵੀ ਕੋਈ ਵੀ worker SIGTERM ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ ਤਾਂ ਇਹ ਜਾਰੀ ਹੁੰਦਾ ਹੈ। ਇਸ event ਨੂੰ log ਕਰਨ ਨਾਲ ਇਸ ਗੱਲ ਦਾ ਉੱਚ-ਪੱਧਰੀ ਦ੍ਰਿਸ਼ ਮਿਲਦਾ ਹੈ ਕਿ ਡਿਪਲਾਈਮੈਂਟਸ ਕਿੰਨੀ ਵਾਰ workers ਨੂੰ ਰੋਕਦੇ ਹਨ।
- JobInterrupted – ਇਹ ਕੇਵਲ ਉਦੋਂ ਜਾਰੀ ਹੁੰਦਾ ਹੈ ਜੇਕਰ ਮੌਜੂਦਾ job Interruptible contract ਨੂੰ ਲਾਗੂ ਕਰਦੀ ਹੈ। ਇਸ event ਦੀ ਵਰਤੋਂ job-ਵਿਸ਼ੇਸ਼ cleanup ਨੂੰ ਤ੍ਰਿਗਰ ਕਰਨ ਲਈ ਕਰੋ, ਜਿਵੇਂ ਕਿ ਟੈਂਪਰੇਰੀ ਫਾਈਲਾਂ ਨੂੰ ਡਿਲੀਟ ਕਰਨਾ ਜਾਂ “last processed row” ਮਾਰਕਰ ਨੂੰ ਅਪਡੇਟ ਕਰਨਾ।
ਇਨ੍ਹਾਂ events ਨੂੰ ਸੁਣਨ ਨਾਲ ਟੀਮਾਂ ਅਜਿਹੇ dashboards ਬਣਾ ਸਕਦੀਆਂ ਹਨ ਜੋ ਡਿਪਲਾਈਮੈਂਟ ਦੇ ਪ੍ਰਭਾਵ ਨੂੰ ਦਿਖਾਉਂਦੇ ਹਨ ਅਤੇ ਉਹਨਾਂ jobs ਦੀ ਪਛਾਣ ਕਰਦੇ ਹਨ ਜੋ ਅਕਸਰ ਅਧੂਰੇ ਰਹਿ ਜਾਂਦੇ ਹਨ।
Queue size reporting ਵਿੱਚ ਸੁਧਾਰ
ਇਹ ਰੀਲੀਜ਼ queue manager ਵਿੱਚ ਇੱਕ totalSize() method ਜੋੜਦੀ ਹੈ, ਜੋ ਸਾਰੀਆਂ queues ਵਿੱਚ ਲੰਬਿਤ (pending) jobs ਦੀ ਕੁੱਲ ਸੰਖਿਆ ਵਾਪਸ ਕਰਦੀ ਹੈ। ਇਹ ਮੁੱਲ database-backed ਅਤੇ Redis drivers ਲਈ ਭਰੋਸੇਯੋਗ ਹੈ, ਜੋ ਅਸਲ ਗਿਣਤੀ ਦੱਸਦੇ ਹਨ। SQS, Sync, ਅਤੇ Beanstalkd ਵਰਗੇ drivers ਅਜੇ ਵੀ ਜ਼ੀਰੋ ਵਾਪਸ ਕਰਦੇ ਹਨ ਕਿਉਂਕਿ ਉਹ Laravel ਦੇ API ਰਾਹੀਂ ਗਿਣਤੀ ਨਹੀਂ ਦਿੰਦੇ। SQS ਦੀ ਵਰਤੋਂ ਕਰਨ ਵਾਲੀਆਂ ਟੀਮਾਂ ਨੂੰ queue ਦੀ ਡੂੰਘਾਈ ਲਈ CloudWatch metrics 'ਤੇ ਭਰੋਸਾ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ।
ਵੱਖ-ਵੱਖ setups ਲਈ ਇਸਦਾ ਕੀ ਮਤਲਬ ਹੈ
- Docker/Kubernetes – ਹੁਣ graceful shutdown ਦੀ ਮਿਆਦ ਦੀ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ। Termination grace period ਨੂੰ ਵਧਾਓ ਤਾਂ ਜੋ jobs ਕੋਲ flag ਨੂੰ ਦੇਖਣ ਅਤੇ ਸਾਫ਼ ਤਰੀਕੇ ਨਾਲ ਬਾਹਰ ਨਿਕਲਣ ਲਈ ਕੁਝ ਸਕਿੰਟ ਹੋਣ।
- Supervisor –
stopwaitsecsਨੂੰ ਉਸ ਸਮੇਂ ਤੋਂ ਵੱਧ ਸੈੱਟ ਕਰੋ ਜਿਸ ਤੋਂ ਬਾਅਦ ਤੁਸੀਂ ਉਮੀਦ ਕਰਦੇ ਹੋ ਕਿ interrupt flag ਪ੍ਰਾਪਤ ਕਰਨ ਤੋਂ ਬਾਅਦ job ਖਤਮ ਹੋ ਜਾਵੇਗੀ। - Legacy jobs – ਕਿਸੇ ਵੀ ਅਜਿਹੇ job ਦੀ ਸਮੀਖਿਆ ਕਰੋ ਜੋ ਮੈਨੇਜਰ ਦੇ timeout ਤੋਂ ਵੱਧ ਸਮਾਂ ਚੱਲਦਾ ਹੈ ਅਤੇ ਜਿੱਥੇ ਸੰਭਵ ਹੋਵੇ, ਇਸਨੂੰ interruptible ਬਣਾਓ।
ਦੂਜਾ ਪੱਖ: ਵਧੀ ਹੋਈ ਜਟਿਲਤਾ (complexity)
ਇਹ ਫੀਚਰ ਸਹੀ timeout configuration ਦੀ ਜਗ੍ਹਾ ਨਹੀਂ ਲੈਂਦਾ। ਜੇਕਰ ਕਿਸੇ job ਦਾ loop ਕਦੇ ਵੀ interruption flag ਦੀ ਜਾਂਚ ਨਹੀਂ ਕਰਦਾ, ਤਾਂ ਮੈਨੇਜਰ ਅਜੇ ਵੀ SIGKILL ਭੇਜੇਗਾ। ਟੀਮਾਂ ਨੂੰ ਲੰਬੇ ਸਮੇਂ ਤੱਕ ਚੱਲਣ ਵਾਲੇ ਕੋਡ ਪਾਥਾਂ ਦੀ ਜਾਂਚ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ ਅਤੇ ਤਰਕਸ਼ੀਲ ਬ੍ਰੇਕਪੁਆਇੰਟਸ 'ਤੇ ਚੈੱਕ ਪਾਉਣੇ ਚਾਹੀਦੇ ਹਨ। ਕੁਝ ਡਿਵੈਲਪਰਾਂ ਨੂੰ ਛੋਟੇ jobs ਲਈ ਵਾਧੂ boilerplate—ਇੱਕ contract ਨੂੰ ਲਾਗੂ ਕਰਨਾ ਅਤੇ flag checks ਜੋੜਨਾ—ਅਣਪਸੰਦ ਲੱਗ ਸਕਦਾ ਹੈ ਜੋ ਪਹਿਲਾਂ ਹੀ shutdown window ਦੇ ਅੰਦਰ ਖਤਮ ਹੋ ਜਾਂਦੇ ਹਨ।
ਐਕਸ਼ਨ ਚੈੱਕਲਿਸਟ
- ਡਿਪਲਾਇਮੈਂਟ ਸਕ੍ਰਿਪਟਾਂ ਵਿੱਚ
--onceਫਲੈਗ ਦੀ ਜਾਂਚ ਕਰੋ ਅਤੇ ਇਸਨੂੰ daemon mode ਨਾਲ ਬਦਲੋ ਜਿੱਥੇ interruptible jobs ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। - ਸਭ ਤੋਂ ਲੰਬੇ ਸਮੇਂ ਤੱਕ ਚੱਲਣ ਵਾਲੇ jobs (ਉਹ ਜੋ ਦਸ ਹਜ਼ਾਰਾਂ rows ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰਦੇ ਹਨ ਜਾਂ ਕਈ ਮਿੰਟਾਂ ਤੱਕ ਚੱਲਦੇ ਹਨ) ਦੀ ਪਛਾਣ ਕਰੋ ਅਤੇ Interruptible contract ਜੋੜੋ।
- ਹਰੇਕ loop iteration ਦੇ ਅੰਦਰ ਇੱਕ flag check ਇਨਸਰਟ ਕਰੋ, ਅਤੇ ਕਿਸੇ ਵੀ ਲੋੜੀਂਦੇ finalisation code ਨੂੰ
interrupted()method ਵਿੱਚ ਬਦਲ ਦਿਓ। - ਡਿਪਲਾਇਮੈਂਟਸ ਪ੍ਰੋਸੈਸਿੰਗ ਨੂੰ ਕਿੰਨੀ ਵਾਰ ਪ੍ਰਭਾਵਿਤ ਕਰਦੇ ਹਨ, ਇਸ ਦੇ metrics ਇਕੱਠੇ ਕਰਨ ਲਈ
WorkerInterruptedਅਤੇJobInterruptedਨਾਲ listeners ਨੂੰ hook ਕਰੋ। - Redis ਜਾਂ database queues ਲਈ, backlog ਦੀ ਨਿਗਰਾਨੀ ਕਰਨ ਲਈ
totalSize()ਦੀ ਵਰਤੋਂ ਕਰੋ; SQS ਲਈ, CloudWatch alarms ਲਗਾ ਕੇ ਰੱਖੋ।
Deployment-driven shutdowns ਨੂੰ ਅਚਾਨਕ ਬੰਦ ਕਰਨ (abrupt kill) ਦੀ ਬਜਾਏ ਇੱਕ ਤਾਲਮੇਲ ਵਾਲੇ ਕਦਮ ਵਜੋਂ ਲਓ। Laravel 13.31 ਡੇਟਾ ਨੂੰ consistent ਰੱਖਦਾ ਹੈ ਅਤੇ ਅਧੂਰੇ ਰਹਿ ਗਏ jobs ਦੀਆਂ operational headaches ਨੂੰ ਘਟਾਉਂਦਾ ਹੈ। ਇਸ ਦਾ ਵਟਾਂਦਰਾ ਕੋਡ ਦੀ ਜ਼ਿੰਮੇਵਾਰੀ ਵਿੱਚ ਮਾਮੂਲੀ ਵਾਧਾ ਹੈ, ਪਰ ਉਹ ਟੀਮਾਂ ਜੋ ਭਾਰੀ background processing 'ਤੇ ਨਿਰਭਰ ਕਰਦੀਆਂ ਹਨ, ਉਹਨਾਂ ਨੂੰ ਇੱਕ ਵਧੇਰੇ ਭਰੋਸੇਯੋਗ production environment ਮਿਲਦਾ ਹੈ।