विलंबित नौकरियां पुनरारंभ करना + कैपिस्ट्रानो सर्वोत्तम प्रथाओं

Question

मैं सिर्फ कैपिस्ट्रानो का उपयोग कर देरी वाले नौकरियों के कर्मचारियों को पुनरारंभ करने के लिए सर्वोत्तम प्रथाओं को समझना चाहता था। मुझे श्रमिकों का एक गुच्छा मिला है जो लंबी नौकरियों को संसाधित करते हैं (10 मिनट तक)।

मैं दो स्थितियों के पार एक तैनाती के दौरान आए हैं, जबकि श्रमिकों processing- हैं

1)

मैंने पहले तैनाती नौकरियों कार्यकर्ताओं में देरी को रोकने: पुनः आरंभ कार्य और तैनाती के बाद उन्हें फिर से शुरू: पुनः आरंभ कार्य ।

लेकिन इस परिदृश्य में, देरी की नौकरियां समाप्त होने तक यह मेरे ऐप को पुनरारंभ नहीं करेगा (यह ठीक हो सकता है - लेकिन काम शुरू होने से पहले कैप तैनाती स्क्रिप्ट सचमुच वहां बैठती है और यह सभी श्रमिकों को रोक सकती है) आगे बढ़ने से पहले ऐप के साथ कार्य को पुनरारंभ करें।

2) मैं भी रोक/पुनः आरंभ कार्य के बाद delayedjobs कार्यकर्ताओं शुरू करने की कोशिश की - लेकिन इस नाटक के सभी प्रकार जिससे कार्य इंतजार कर अभी तक delayedjobs तालिका उन्हें सूचीबद्ध किया था और एक के साथ एक कर्मी को असाइन बिना रुका किया जाएगा वजह से पीआईडी ​​जो अस्तित्व में नहीं है!

कोई अन्य विकल्प? या मुझे परिदृश्य में उल्लिखित प्रतीक्षा करने के लिए मजबूर किया गया है।

बहुत धन्यवाद।

संपादित करें: मुझे बस परिदृश्य 1 के साथ एहसास हुआ .. यह इंतजार नहीं करता! स्टॉप टास्क मेरे कार्यकर्ता को मजबूर कर देगा, भले ही यह खत्म नहीं हुआ हो!

** [out] delayed_job: trying to stop process with pid 9630... 
** [out] delayed_job: process with pid 9630 won't stop, we forcefully kill it... 
** [out] 
** [out] delayed_job: process with pid 9630 successfully stopped. 

Answer 1

आप एक साझा निर्देशिका में अपने पीआईडी ​​फ़ाइल डाल करने के लिए यह गायब से बचने के लिए दूसरे परिदृश्य को ठीक कर सकते हैं। दूसरा परिदृश्य काम कर सकता है और यदि आपके पास कुछ देरी नहीं है तो आपकी देरी वाली नौकरी के साथ संघर्ष हो सकता है।

Answer 2

यदि आपके तैनाती परिवर्तन डेटाबेस स्कीमा को बदलते हैं, तो आपको प्रतीक्षा करने के लिए मजबूर होना पड़ता है।

यदि ऐसा नहीं होता है, तो आप एक झंडा सेट कर सकते हैं जो श्रमिक प्रत्येक नौकरी के अंत में जांचते हैं। तैनाती पर, आप ध्वज सेट करते हैं, और एक बार लंबे समय तक चलने वाले कार्यकर्ता खत्म होने के बाद, यह एक नए कार्यकर्ता को निष्पादित करके स्वयं को बदल देता है। इस तरह आप वास्तव में कभी भी श्रमिकों को शुरू नहीं कर रहे हैं और रोक रहे हैं - वे हमेशा चल रहे हैं, और अगली नौकरी शुरू करने के लिए नवीनतम कोड लोड करेंगे।

Answer 3

मैंने डेमन्स मणि का उपयोग करके अपनी "लंबी चल रही प्रक्रियाओं" को एक कस्टम रूबी स्क्रिप्ट में स्थानांतरित कर दिया। हालांकि सलाह के लिए धन्यवाद दोस्तों!

Answer 4

अच्छा सवाल - मैंने कई अलग-अलग चीजों की कोशिश की है, लेकिन मेरी रणनीति चीजों को सरल रखना है।

1. ईश्वर या मोनीट या रूट के रूप में चलने वाली किसी भी चीज़ का उपयोग न करें, उसी उपयोगकर्ता को जो आपके ऐप को फिर से शुरू करने के लिए सूडो विशेषाधिकारों की आवश्यकता है, की आवश्यकता नहीं है। रेल सुरक्षा में हालिया घटनाओं को देखते हुए, आखिरी चीज जो आप चाहते हैं वह है कि आपके ऐप उपयोगकर्ता को रूट प्राप्त करने की अच्छी संभावना है।
2. इसके बजाय, कार्यों को शुरू/बंद/पुनरारंभ करने के लिए rake या thor कार्य का उपयोग करें।
3. प्रक्रिया को डिमन करने के लिए nohup का उपयोग करें।अपने deploy.rb फ़ाइल में

   class Resque < Thor 
   
       desc "start", "Starts resque workers" 
       def start 
       system('(PIDFILE=/tmp/resque-myapp.pid nohup rake resque:work QUEUES="*" &) &') 
       end 
   
       desc "stop", "Stops resque workers" 
       def stop 
       pidfile = '/tmp/resque-myapp.pid' 
       if File.exist?(pidfile) 
        pid = File.open(pidfile).first.to_i 
        puts "Killing process #{pid}..." 
        system("kill -QUIT #{pid}") 
        File.delete(pidfile) 
        sleep(5) 
       else 
        puts "No resque pidfile found" 
       end 
       end 
   end 
   

   तब:

   after 'deploy',   "resque:restart" 
   
   namespace :resque do 
       task :restart do 
       puts "Stopping resque workers.." 
       run("cd #{current_path} && thor resque:stop", :options => { :pty => true }) 
       puts "Starting resque workers.." 
       run("cd #{current_path} && thor resque:start > /dev/null 2>&1 &", :options => { :pty => true }) 
       end 
   end 
   

   यह रणनीति भी काम कर सकते हैं

यहाँ कुछ बहुत ही बुनियादी थोर कार्यों, resque के साथ सरल पृष्ठभूमि कार्य का प्रबंधन कर सकते उदाहरण के लिए कर रहे हैं आरवीएम के साथ, अगर वह ब्याज की है। RVM साथ यह ~/.bashrc में लाना सबसे अच्छा है

after 'deploy:setup', 'thor:install' 
namespace :thor do 
    task :install do 
    puts "Installing thor..." 
    run_locally('cap rvm:install_gem GEM=thor') 
    end 
end 

after "deploy",   "rvm:trust_rvmrc" 
namespace :rvm do 
    task :trust_rvmrc do 
    run "rvm rvmrc trust #{release_path}" 
    end 
end 

और अंत में कम से कम, क्या संस्थापक सामान्य रूप से उस फ़ाइल और .bash_profile के बीच विभाजन: आप हमेशा की तरह rvm-capistrano कार्यों को कुछ इस तरह पुनः आरंभ आदेश से पहले, इसके अलावा में की आवश्यकता होगी , और सुनिश्चित करें कि फ़ाइल की विधा 0400 तो यह प्रोग्राम स्थापित RVM द्वारा clobbered कर नहीं होगा बनाने:

PATH=$HOME/.rvm/bin:/usr/local/bin/:$PATH # Add RVM to PATH for scripting 
export PATH 
export RAILS_ENV=production 
[[ -s "$HOME/.rvm/scripts/rvm" ]] && source "$HOME/.rvm/scripts/rvm" 

Answer 5

मैं तुम्हें बाहर whenever जाँच की सिफारिश करेंगे - देरी नौकरियों के प्रबंधन के लिए शायद सबसे अच्छा मणि। मैंने पुराने भूल गए क्रॉन + wget से शुरू होने वाले विभिन्न समाधानों की कोशिश की, लेकिन जब भी इस पर सबसे अच्छा नियंत्रण मिलता है। और यह Capistrano के साथ महान एकीकृत करता है। एचटीएच

Answer 6

वास्तव में यह सुनिश्चित नहीं है कि मेरा समाधान पर्याप्त है। लेकिन वैसे भी इसे जीने का मौका है। बस एक रैक कार्य बनाने और तैनाती प्रक्रिया पर इसे शुरू:

desc 'Wait for delayed job completion' 
    task wait_for_complete_background_jobs: :environment do 
    loop do 
     exit unless Delayed::Job.where(locked_at: nil).exists? 
     sleep 2 
    end 
    end 

रेक कार्य सही बंद कर दिया कार्यों सूची के बाद बंद कर दिया नौकरियों और बाहर निकलता है के लिए इंतज़ार कर रहा है खाली है। इस तरह मैं इसके उपयोग की कल्पना है (ध्यान दें, आपरेशन के अनुक्रम महत्वपूर्ण है):

1. बंद करो वेब सर्वर
रेक कार्य
2. बंद करो देरी काम
3. अद्यतन कोड
4. प्रारंभ शुरू
5. देरी नौकरी
6. वेब सर्वर