Ho già un deploy.rb che può distribuire la mia app sul mio server di produzione.

La mia app contiene un'attività rake personalizzata (un file .rake nella directory lib / tasks).

Vorrei creare un'attività cap che eseguirà in remoto tale attività rake.

Un po 'più esplicito, nel tuo \config\deploy.rb, aggiungi al di fuori di qualsiasi attività o spazio dei nomi:

namespace :rake do  
  desc "Run a task on a remote server."  
  # run like: cap staging rake:invoke task=a_certain_task  
  task :invoke do  
    run("cd #{deploy_to}/current; /usr/bin/env rake #{ENV['task']} RAILS_ENV=#{rails_env}")  
  end  
end

Quindi, da /rails_root/, puoi eseguire:

cap staging rake:invoke task=rebuild_table_abc

... un paio d'anni dopo ...

Dai un'occhiata al plug-in rails di capistrano, puoi vedere su https://github.com/capistrano/rails/blob/master/lib/capistrano/tasks/migrations.rake#L5-L14 può assomigliare a:

desc 'Runs rake db:migrate if migrations are set'
task :migrate => [:set_rails_env] do
  on primary fetch(:migration_role) do
    within release_path do
      with rails_env: fetch(:rails_env) do
        execute :rake, "db:migrate"
      end
    end
  end
end

Capistrano 3 Generic Version (esegui qualsiasi attività rake)

Costruire una versione generica della risposta di Mirek Rusin:

desc 'Invoke a rake command on the remote server'
task :invoke, [:command] => 'deploy:set_rails_env' do |task, args|
  on primary(:app) do
    within current_path do
      with :rails_env => fetch(:rails_env) do
        rake args[:command]
      end
    end
  end
end

Utilizzo di esempio: cap staging "invoke[db:migrate]"

Nota che deploy:set_rails_envrichiede proviene dalla gemma capistrano-rails

run("cd #{deploy_to}/current && /usr/bin/env rake `<task_name>` RAILS_ENV=production")

Trovato con Google - http://ananelson.com/said/on/2007/12/30/remote-rake-tasks-with-capistrano/

L' RAILS_ENV=productionera un Gotcha - non pensavo di esso in un primo momento e non riusciva a capire perché il compito non stava facendo niente.

Usa invocazioni rake in stile Capistrano

C'è un modo comune con cui "funzionerà" require 'bundler/capistrano'e altre estensioni che modificano rake. Funzionerà anche con gli ambienti di pre-produzione se utilizzi il multistadio. Il succo? Usa config vars se puoi.

desc "Run the super-awesome rake task"
task :super_awesome do
  rake = fetch(:rake, 'rake')
  rails_env = fetch(:rails_env, 'production')

  run "cd '#{current_path}' && #{rake} super_awesome RAILS_ENV=#{rails_env}"
end

Usa la capistrano-rakegemma

Basta installare la gemma senza perdere tempo con le ricette personalizzate di capistrano ed eseguire le attività di rake desiderate su server remoti come questo:

cap production invoke:rake TASK=my:rake_task

Full Disclosure: l'ho scritto

Personalmente utilizzo in produzione un metodo di supporto come questo:

def run_rake(task, options={}, &block)
  command = "cd #{latest_release} && /usr/bin/env bundle exec rake #{task}"
  run(command, options, &block)
end

Ciò consente di eseguire attività rake in modo simile all'utilizzo del metodo run (comando).

NOTA: è simile a quanto proposto da Duke , ma io:

• usa latest_release invece di current_release - dalla mia esperienza è più quello che ti aspetti quando esegui un comando rake;
• segui la convenzione di denominazione di Rake e Capistrano (invece di: cmd -> task e rake -> run_rake)
• non impostare RAILS_ENV = # {rails_env} perché il posto giusto per impostarlo è la variabile default_run_options. Ad esempio default_run_options [: env] = {'RAILS_ENV' => 'production'} # -> DRY!

C'è un interessante mantello di gemme che rende le tue attività di rastrello disponibili come attività di Capistrano, quindi puoi eseguirle da remoto. capeè ben documentato, ma ecco una breve panoramica su come configurarlo.

Dopo aver installato la gemma, aggiungila al tuo config/deploy.rbfile.

# config/deploy.rb
require 'cape'
Cape do
  # Create Capistrano recipes for all Rake tasks.
  mirror_rake_tasks
end

Ora puoi eseguire tutte le rakeattività in locale o in remoto tramite cap.

Come bonus aggiuntivo, capeti consente di impostare il modo in cui desideri eseguire l'attività di rake localmente e da remoto (non di più bundle exec rake), aggiungilo al tuo config/deploy.rbfile:

# Configure Cape to execute Rake via Bundler, both locally and remotely.
Cape.local_rake_executable  = '/usr/bin/env bundle exec rake'
Cape.remote_rake_executable = '/usr/bin/env bundle exec rake'

namespace :rake_task do
  task :invoke do
    if ENV['COMMAND'].to_s.strip == ''
      puts "USAGE: cap rake_task:invoke COMMAND='db:migrate'" 
    else
      run "cd #{current_path} && RAILS_ENV=production rake #{ENV['COMMAND']}"
    end
  end                           
end 

Ecco cosa inserisco nel mio deploy.rb per semplificare l'esecuzione delle attività di rake. È un semplice involucro attorno al metodo run () di capistrano.

def rake(cmd, options={}, &block)
  command = "cd #{current_release} && /usr/bin/env bundle exec rake #{cmd} RAILS_ENV=#{rails_env}"
  run(command, options, &block)
end

Quindi eseguo qualsiasi attività di rake in questo modo:

rake 'app:compile:jammit'

Questo ha funzionato per me:

task :invoke, :command do |task, args|
  on roles(:app) do
    within current_path do
      with rails_env: fetch(:rails_env) do
        execute :rake, args[:command]
      end
    end
  end
end

Quindi corri semplicemente cap production "invoke[task_name]"

La maggior parte è da sopra risposta con un piccolo miglioramento per eseguire qualsiasi attività di rake da capistrano

Esegui qualsiasi attività di rake da capistrano

$ cap rake -s rake_task=$rake_task

# Capfile     
task :rake do
  rake = fetch(:rake, 'rake')
  rails_env = fetch(:rails_env, 'production')

  run "cd '#{current_path}' && #{rake} #{rake_task} RAILS_ENV=#{rails_env}"
end

Funziona anche:

run("cd #{release_path}/current && /usr/bin/rake <rake_task_name>", :env => {'RAILS_ENV' => rails_env})

Maggiori informazioni: Capistrano Run

Se vuoi essere in grado di passare più argomenti, prova questo (basato sulla risposta di marinosbern):

task :invoke, [:command] => 'deploy:set_rails_env' do |task, args|
  on primary(:app) do
    within current_path do
      with :rails_env => fetch(:rails_env) do
        execute :rake, "#{args.command}[#{args.extras.join(",")}]"
      end
    end
  end
end

Quindi puoi eseguire un'attività in questo modo: cap production invoke["task","arg1","arg2"]

Quindi ci ho lavorato. sembra funzionare bene. Tuttavia è necessario un formatore per sfruttare davvero il codice.

Se non si desidera utilizzare un formattatore, è sufficiente impostare il livello di registro in modalità di debug. Questi sema alle h

SSHKit.config.output_verbosity = Logger::DEBUG

Cap Stuff

namespace :invoke do
  desc 'Run a bash task on a remote server. cap environment invoke:bash[\'ls -la\'] '
  task :bash, :execute do |_task, args|
    on roles(:app), in: :sequence do
      SSHKit.config.format = :supersimple
      execute args[:execute]
    end
  end

  desc 'Run a rake task on a remote server. cap environment invoke:rake[\'db:migrate\'] '
  task :rake, :task do |_task, args|
    on primary :app do
      within current_path do
        with rails_env: fetch(:rails_env) do
          SSHKit.config.format = :supersimple
          rake args[:task]
        end
      end
    end
  end
end

Questo è il formattatore che ho creato per funzionare con il codice sopra. Si basa sul: textimple integrato in sshkit ma non è un brutto modo per invocare attività personalizzate. Oh, molti non funzionano con la versione più recente di sshkit gem. So che funziona con 1.7.1. Dico questo perché il ramo master ha cambiato i metodi SSHKit :: Command che sono disponibili.

module SSHKit
  module Formatter
    class SuperSimple < SSHKit::Formatter::Abstract
      def write(obj)
        case obj
        when SSHKit::Command    then write_command(obj)
        when SSHKit::LogMessage then write_log_message(obj)
        end
      end
      alias :<< :write

      private

      def write_command(command)
        unless command.started? && SSHKit.config.output_verbosity == Logger::DEBUG
          original_output << "Running #{String(command)} #{command.host.user ? "as #{command.host.user}@" : "on "}#{command.host}\n"
          if SSHKit.config.output_verbosity == Logger::DEBUG
            original_output << "Command: #{command.to_command}" + "\n"
          end
        end

        unless command.stdout.empty?
          command.stdout.lines.each do |line|
            original_output << line
            original_output << "\n" unless line[-1] == "\n"
          end
        end

        unless command.stderr.empty?
          command.stderr.lines.each do |line|
            original_output << line
            original_output << "\n" unless line[-1] == "\n"
          end
        end

      end

      def write_log_message(log_message)
        original_output << log_message.to_s + "\n"
      end
    end
  end
end

Le risposte precedenti non mi hanno aiutato e ho trovato questo: da http://kenglish.co/run-rake-tasks-on-the-server-with-capistrano-3-and-rbenv/

namespace :deploy do
  # ....
  # @example
  #   bundle exec cap uat deploy:invoke task=users:update_defaults
  desc 'Invoke rake task on the server'
  task :invoke do
    fail 'no task provided' unless ENV['task']

    on roles(:app) do
      within release_path do
        with rails_env: fetch(:rails_env) do
          execute :rake, ENV['task']
        end
      end
    end
  end

end

per eseguire la tua attività usa

bundle exec cap uat deploy:invoke task=users:update_defaults

Forse sarà utile per qualcuno