Laravel 13.31 interruptible jobs ઉમેરે છે, જે queue workers ને ડિપ્લોયમેન્ટ દરમિયાન મોકલવામાં આવતા SIGTERM સિગ્નલને પકડવામાં અને કાર્ય અધવચ્ચેથી અટકાવવાને બદલે વ્યવસ્થિત રીતે બંધ થવામાં મદદ કરે છે. જે ટીમો લાંબા સમય સુધી ચાલતા jobs ચલાવે છે—જેમ કે હજારો rows પ્રોસેસ કરવી, બલ્ક ઈમેઈલ્સ મોકલવા, અથવા રિપોર્ટ્સ જનરેટ કરવા—તેમને આનો ફાયદો થાય છે કારણ કે જ્યારે નવું રિલીઝ રોલ આઉટ થાય છે ત્યારે ડેટા સુસંગત (consistent) રહે છે.

ડિપ્લોયમેન્ટ્સ શા માટે jobs ને ખતમ કરી રહ્યા છે

જ્યારે નવું વર્ઝન આવે છે, ત્યારે Supervisor, Docker, અને Kubernetes જેવા પ્રોસેસ મેનેજર્સ SIGTERM મોકલીને હાલના workers ને અટકાવવાનું કહે છે, જે સમાપ્તિ માટેની એક નમ્ર વિનંતી છે. મોટાભાગના workers બહાર નીકળતા પહેલા વર્તમાન job પૂર્ણ થવાની રાહ જુએ છે. સમસ્યા ત્યારે થાય છે જ્યારે મેનેજર આ પાલન કરવા માટે માત્ર થોડી સેકન્ડો જ આપે છે. જો કોઈ job ને મિનિટોની જરૂર હોય, તો મેનેજર SIGKILL તરફ આગળ વધે છે, જે પ્રોસેસને તરત જ મારી નાખે છે. આના કારણે job ક્યારેય સુસંગત સ્થિતિમાં પહોંચી શકતું નથી, જેનાથી અંશતઃ અપડેટ થયેલા રેકોર્ડ્સ, ઓર્ફેન્ડ ફાઇલો (orphaned files), અથવા ડુપ્લીકેટ કામ જેવી સમસ્યાઓ સર્જાય છે.

Laravel નો જવાબ: cooperative interruption

Laravel 13.31 Interruptible નામનો એક contract રજૂ કરે છે જેને job class અમલમાં (implement) મૂકી શકે છે જેથી તે termination request વિશે જાણી શકે. જ્યારે SIGTERM આવે છે, ત્યારે Laravel job ની interrupted() મેથડને કોલ કરે છે. ફ્રેમવર્ક job ને આપમેળે અટકાવતું નથી; job એ Laravel દ્વારા સેટ કરવામાં આવેલા ફ્લેગને ચેક કરવો જોઈએ અને જાતે જ બહાર નીકળવું જોઈએ. આ સહકારી મોડેલ (cooperative model) ડેવલપર્સને વર્તમાન લૂપ ઇટરેશન પૂર્ણ કરવા, આંશિક ફેરફારોને રોલ બેક (roll back) કરવા, અથવા બહાર નીકળતા પહેલા ચેકપોઈન્ટ લખવાની મંજૂરી આપે છે.

Job ને interruptible કેવી રીતે બનાવવું

  1. Contract અમલમાં મૂકો – job class ની વ્યાખ્યામાં implements Interruptible ઉમેરો.
  2. વર્ક લૂપની અંદર ફ્લેગ ચેક કરો – દરેક ઇટરેશનમાં ચેક ઉમેરો કે job અટકવું જોઈએ કે નહીં.
  3. ક્લીનઅપ કરો – interrupted() માં, કોઈપણ સ્ટેટને સાચવો (persist) જે job ને પછીથી ફરી શરૂ કરવા દેશે, અથવા પછીથી વિશ્લેષણ માટે અવરોધને લોગ કરો.

સૌથી મોટો trap: --once નો ઉપયોગ કરશો નહીં

php artisan queue:work --once સાથે queue worker ચલાવવાથી સિગ્નલ હેન્ડલિંગ સંપૂર્ણપણે નિષ્ક્રિય થઈ જાય છે. વર્કર એક જ job પ્રોસેસ કરે છે અને બહાર નીકળી જાય છે, પરંતુ તે ક્યારેય SIGTERM હેન્ડલર રજિસ્ટર કરતું નથી. પરિણામે, કોઈપણ interruptible job સમાપ્તિ વિનંતીને અવગણે છે અને પ્રોસેસની વચ્ચે જ મારી નાખવામાં આવે છે. આ પેટર્ન cron-driven કન્ટેનર્સ અને one-shot ડિપ્લોયમેન્ટ્સમાં જોવા મળે છે. જ્યારે પણ તમારે interruptible jobs ની જરૂર હોય ત્યારે daemon mode (php artisan queue:work) ચલાવીને તેને સુધારો.

અવરોધો (interruptions) પર નજર રાખવી

Laravel બે ઇવેન્ટ્સ ફાયર કરે છે જેમાં તમે હૂક કરી શકો છો:

  • WorkerInterrupted – જ્યારે પણ કોઈ વર્કર SIGTERM મેળવે છે ત્યારે આ ઇવેન્ટ ઇમિટ થાય છે. આ ઇવેન્ટને લોગ કરવાથી ડિપ્લોયમેન્ટ્સ કેટલી વાર વર્કર્સને અવરોધે છે તેનો ઉચ્ચ સ્તરીય વ્યુ (high-level view) મળે છે.
  • JobInterrupted – આ ઇવેન્ટ ફક્ત ત્યારે જ ઇમિટ થાય છે જો વર્તમાન job Interruptible contract ને અમલમાં મૂકે છે. આ ઇવેન્ટનો ઉપયોગ job-specific ક્લીનઅપ કરવા માટે કરો, જેમ કે કામચલાઉ ફાઇલો ડિલીટ કરવી અથવા “last processed row” માર્કર અપડેટ કરવું.

આ ઇવેન્ટ્સને સાંભળવાથી ટીમો એવા ડેશબોર્ડ બનાવી શકે છે જે ડિપ્લોયમેન્ટની અસર દર્શાવે છે અને વારંવાર અધવચ્ચેથી કપાઈ જતા jobs ને ઓળખી શકે છે.

Queue size રિપોર્ટિંગમાં સુધારો

આ રિલીઝ queue manager માં totalSize() મેથડ ઉમેરે છે, જે તમામ queues માં પેન્ડિંગ jobs ની કુલ સંખ્યા રિટર્ન કરે છે. આ કિંમત database-backed અને Redis ડ્રાઇવર્સ માટે વિશ્વસનીય છે, જે વાસ્તવિક કાઉન્ટ રિપોર્ટ કરે છે. SQS, Sync, અને Beanstalkd જેવા ડ્રાઇવર્સ હજુ પણ શૂન્ય રિટર્ન કરે છે કારણ કે તેઓ Laravel ના API દ્વારા કાઉન્ટ દર્શાવતા નથી. SQS વાપરતી ટીમોએ queue depth માટે CloudWatch મેટ્રિક્સ પર નિર્ભર રહેવું જોઈએ.

વિવિધ સેટઅપ માટે આનો અર્થ શું છે

  • Docker/Kubernetes – ગ્રેસફુલ શટડાઉન પિરિયડનો હવે અસરકારક રીતે ઉપયોગ કરી શકાય છે. termination grace period વધારો જેથી jobs ને ફ્લેગ નોંધવા અને વ્યવસ્થિત રીતે બહાર નીકળવા માટે થોડી સેકન્ડો મળે.
  • Supervisor – stopwaitsecs ને તમે ઇન્ટરપ્ટ ફ્લેગ મેળવ્યા પછી job પૂર્ણ થવાની અપેક્ષા રાખતા સમય કરતા વધારે સેટ કરો.
  • Legacy jobs – કોઈપણ job જે મેનેજરના timeout કરતા વધુ સમય ચાલે છે તેનું રિવ્યુ કરો અને જ્યાં શક્ય હોય ત્યાં તેને interruptible બનાવો.

વિરોધ પક્ષ: વધેલી જટિલતા

આ ફીચર યોગ્ય timeout કોન્ફિગરેશનનું સ્થાન લેતું નથી. જો કોઈ job ના લૂપમાં ક્યારેય ઇન્ટરપ્શન ફ્લેગ ચેક કરવામાં ન આવે, તો મેનેજર હજુ પણ SIGKILL મોકલશે. ટીમોએ લાંબા સમય સુધી ચાલતા કોડ પાથનું ઓડિટ કરવું જોઈએ અને તાર્કિક બ્રેકપોઈન્ટ્સ પર ચેક ઉમેરવા જોઈએ. કેટલાક ડેવલપર્સને ટૂંકા jobs માટે—જે પહેલેથી જ શટડાઉન વિન્ડોની અંદર પૂર્ણ થાય છે—વધારાનું બોઈલરપ્લેટ (contract અમલમાં મૂકવું અને ફ્લેગ ચેક ઉમેરવા) અપ્રિય લાગી શકે છે.

એક્શન ચેકલિસ્ટ

  1. ડિપ્લોયમેન્ટ સ્ક્રિપ્ટ્સમાં --once ફ્લેગ શોધો અને તેને ડેમન મોડ (daemon mode) સાથે બદલો જ્યાં ઇન્ટરપ્ટિબલ (interruptible) જોબ્સનો ઉપયોગ કરવામાં આવે છે.
  2. સૌથી લાંબો સમય ચાલતા જોબ્સ (જે હજારો રો (rows) પર કામ કરે છે અથવા ઘણા મિનિટો સુધી ચાલે છે) ઓળખો અને તેમાં Interruptible contract ઉમેરો.
  3. દરેક લૂપ ઇટરેશન (loop iteration) ની અંદર ફ્લેગ ચેક ઉમેરો, અને કોઈપણ જરૂરી ફાઇનલાઇઝેશન કોડને interrupted() મેથડમાં ખસેડો.
  4. ડિપ્લોયમેન્ટ્સ પ્રોસેસિંગને કેટલી વાર અસર કરે છે તેના પર મેટ્રિક્સ (metrics) એકત્રિત કરવા માટે WorkerInterrupted અને JobInterrupted સાથે લિસનર્સ (listeners) ને હૂક કરો.
  5. Redis અથવા ડેટાબેઝ ક્યુઝ (queues) માટે, બેકલોગ (backlog) મોનિટર કરવા માટે totalSize() નો ઉપયોગ કરો; SQS માટે, CloudWatch એલાર્મ્સ સક્રિય રાખો.

ડિપ્લોયમેન્ટ-ડ્રિવન શટડાઉન (deployment-driven shutdowns) ને અચાનક બંધ કરવાને બદલે એક સંકલિત પગલા તરીકે ગણો. Laravel 13.31 ડેટાને સુસંગત રાખે છે અને અધૂરી રહેલી જોબ્સની ઓપરેશનલ મુશ્કેલીઓને ઘટાડે છે. આમાં કોડની જવાબદારીમાં થોડો વધારો થાય છે, પરંતુ જે ટીમો હેવી બેકગ્રાઉન્ડ પ્રોસેસિંગ પર આધાર રાખે છે તેમને વધુ વિશ્વસનીય પ્રોડક્શન એન્વાયરમેન્ટ મળે છે.