Distribuzione di Capistrano con Subversion

Distribuzione di Capistrano

Capistrano è uno strumento utilizzato per l'automazione del processo di distribuzione dell'applicazione. Capistrano viene utilizzato principalmente per la distribuzione di app ferroviarie. Le modifiche apportate all'app rails possono essere facilmente trasferite al server utilizzando la distribuzione dei cap. Capistrano può essere configurato con qualsiasi sistema di controllo della versione come SVN/GIT per la distribuzione di un'app. Inoltre, possiamo definire il tipo di server dell'applicazione (mongrel, mod_rails / Fcgi) su cui l'app è stata distribuita in Capistrano. Qui discuterò del limite della distribuzione di un'app utilizzando SVN con il cluster Mongrel come server delle applicazioni.

Capistrano può essere installato come una gemma di rubino come mostrato di seguito: $ gemma installa capistrano

Configurazione di un'app Rails per utilizzare Capistrano:

Questo può essere fatto eseguendo il seguente comando dall'app rails:

$ capifica .

Il comando precedente creerà un file Capfile E config/deploy.rb file.

utente@nomehost [~/railsapp]$ capify . [aggiungi] scrivendo './Capfile' [aggiungi] scrivendo './config/deploy.rb'

utente@nomehost [~/railsapp]$ cat Capfile

carica 'deploy' se rispondi_to?(:namespace) # cap2 differenziatore Dir['vendor/plugins/*/recipes/*.rb'].each { |plugin| carica(plug-in) }

caricare 'config/deploy' # rimuovere questa riga per saltare il caricamento di qualsiasi attività predefinita

utente@nomehost [~/railsapp]$ cat config/deploy.rb

set :application, “imposta il nome della tua applicazione qui” set :repository, “imposta la posizione del tuo repository qui”

# Se non stai distribuendo su /u/apps/#{applicazione} sui server # di destinazione (che è l'impostazione predefinita), puoi specificare la posizione effettiva # tramite la variabile :deploy_to: # set :deploy_to, “/var /www/#{applicazione}”

# Se non utilizzi Subversion per gestire il codice sorgente, specifica # il tuo SCM di seguito: # set :scm, :subversion

role :app, "il tuo server app qui" role :web, "il tuo server web qui" role :db, "il tuo server db qui", :primary => true

PS: In alternativa possiamo creare direttamente Capfile E distribuire.rb file sotto l'app rails e carica i dati necessari utilizzando l'editor "vi".

Capfile e Deploy.rb:

Il Capfile contiene tutte le attività che devono essere eseguite durante la distribuzione del cap. Tutte le funzioni (task) all'interno del Capfile possono essere definite utilizzando la parola chiave 'task'. Il gruppo di funzioni è definito spazio dei nomi.

Capfile di esempio:

carica 'deploy' se rispondi_to?(:namespace) # differenziatore cap2

carica 'config/deploy'

spazio dei nomi :deploy do

attività :start, :roles => :app do

esegui “cd #{current_path} && mongrel_rails cluster::configure -e production -p #{mongrel_port} -N #{mongrel_nodes} -c #{current_path} –user #{user} –group #{user}”

esegui "cd #{current_path} && mongrel_rails cluster::start"

esegui "rm -rf /home/#{utente}/public_html; ln -s #{percorso_corrente}/public /home/#{utente}/public_html”

esegui "mkdir -p #{deploy_to}/shared/config"

esegui "mv #{current_path}/config/mongrel_cluster.yml #{deploy_to}/shared/config/mongrel_cluster.yml"

eseguire "ln -s #{deploy_to}/shared/config/mongrel_cluster.yml #{current_path}/config/mongrel_cluster.yml"

FINE

attività :restart, :roles => :app do

eseguire "ln -s #{deploy_to}/shared/config/mongrel_cluster.yml #{current_path}/config/mongrel_cluster.yml"

esegui "cd #{current_path} && mongrel_rails cluster::restart"

esegui "cd #{current_path} && chmod 755 #{chmod755}"

FINE

FINE

Il file config/deploy.rb contiene tutte le variabili utilizzate durante la distribuzione del cap. Supponiamo che nel Capfile sopra stiamo accedendo a diverse variabili come: mongrel_port, user, chmod755 ecc. Lo stesso dovrebbe essere prima definito nel file config/deploy.rb, quindi solo Capistrano eseguirà l'attività correttamente.

Esempio di configurazione/deploy.rb:

imposta:applicazione, “railsapp”

imposta: dominio, “nome host”

imposta:utente, “utente”

imposta: repository, "svn+ssh://#{utente}@#{dominio}/home/#{utente}/svn/#{applicazione}/trunk"

imposta :use_sudo, false

imposta:group_writable, falso

imposta:deploy_to, "/home/#{utente}/apps/#{applicazione}"

imposta :deploy_via, :checkout

set: chmod755, "app config db lib script del fornitore pubblico script/* public/disp*"

imposta:mongrel_port, “4000”

imposta:mongrel_nodes, “2”

default_run_options[:pty] = vero

ruolo: app, dominio

ruolo: web, dominio

ruolo :db, dominio, :primary => true

Qui dobbiamo inserire il nome dell'applicazione, il nome di dominio e l'utente ssh appropriati. L'app rails deve essere importata nel repository svn prima di procedere con la distribuzione del cap. Il repository SVN può essere configurato come mostrato di seguito.

utente@nomehost [~]$ mkdir svn

utente@nomehost [~]$ svnadmin crea ~/svn/railsapp

PS: assicurati di fornire lo stesso nome dell'app rails anche al repository svn.

Una volta terminato, possiamo importare l'app rails nel repository svn:

utente@nomehost [~]$ mkdir -p ~/temp/railsapp/tags ~/temp/railsapp/branches

utente@nomehost [~]$ cp -pR ~/railsapp ~/temp/railsapp/trunk

Qui assicurati di fornire il percorso completo a railsapp (la tua directory dell'app rails) durante la creazione della directory trunk. Anche l'utente, l'applicazione e il dominio corretti devono essere forniti nel trunk/config/deploy.rb.

L'app Rails si troverà nella directory trunk e ora potrà essere importata nel repository svn.

utente@nomehost [~]$ svn import temp/railsapp file:///home/utente/svn/railsapp -m “messaggio”

L'app rails importata nel repository svn (ad esempio, situata sul server) può essere estratta sul computer locale come mostrato di seguito:

utente@localmachine [~]$ svn co svn+ssh://utente@nomehost/home/utente/svn/railsapp/nome cartella trunk

Password: password SSH dell'utente

Ora possiamo trovare il capfile modificato e il file deploy.rb nella cartella estratta. Successivamente, da RAILS_ROOT dell'applicazione della versione locale eseguire il seguente comando.

Distribuzione del cappuccio $: installazione

Distribuzione del cappuccio $: freddo

Il comando "cap deploy:setup" imposterà la struttura di directory iniziale richiesta per l'app cap distribuita.

Dire,

/home/utente/app

/home/utente/app/nomeapp

/home/utente/apps/nomeapp/releases

/home/utente/apps/nomeapp/condivisa

Il comando 'cap deploy:cold' estrarrà l'app rails dal repository svn e la inserirà in una directory all'interno – /home/user/apps/appname/releases. Successivamente verrà creato un collegamento simbolico da /home/utente/apps/nomeapp/releases/ /home/utente/apps/nomeapp/current. Inoltre la root del documento punterà alla directory pubblica della versione corrente come menzionato nel Capfile.

La directory di rilascio contiene le app distribuite nel server e la cartella delle app verrà denominata in base alla data e all'ora in cui l'app rails è stata distribuita in modo limitato.

Dire,

utente@nomehost [~/apps/railsapp/releases]$ ls -al

totale 24

drwxrwxr-x 6 utente utente 4096 28 aprile 2009 .

drwxrwxr-x 4 utente utente 4096 9 luglio 2009 ..

drwxr-xr-x 16 utente utente 4096 15 ottobre 2008 20081015183834

drwxr-xr-x 21 utente utente 4096 3 febbraio 2009 20081015183941

drwxr-xr-x 8 utente utente 4096 28 aprile 2009 20090428215604

drwxr-xr-x 8 utente utente 4096 28 aprile 2009 20090428221701

Le directory comuni nell'app rails (ad esempio immagini, file di configurazione, file di registro) vengono inserite nella directory condivisa e collegate simbolicamente alla versione corrente.

Riferimenti: http://www.capify.org/index.php/Capistrano http://www.hostingrails.com/Capistrano-2-x-Deploying-Your-Rails-Application-on-HostingRails-com

Collaboratore : Vinayan