Distribuzione di un'applicazione Rails con Capistrano e Phusion Passenger

Il deploy di un'applicazione rails sui server è un'operazione complicata se eseguita manualmente, poiché richiede il login ai server, l'upload del codice dal sistema locale ogni volta e il mantenimento del backup degli aggiornamenti se si vuole tornare indietro.

Questo processo richiede molto tempo e dobbiamo arrestare, avviare e riavviare i server delle applicazioni ogni volta che dobbiamo aggiornarli. Questo compito può essere semplificato utilizzando questi due strumenti di distribuzione, cioè Capistrano E Passeggero Phusion (chiamato anche “mod_rails”).

La procedura di installazione di entrambi gli strumenti è molto simile, poiché entrambi vengono installati come gemme di Rails. Questa è la specialità di Struttura Rails che disponga di tutti gli strumenti necessari per operare come gemme.

Ma la differenza è che Capistrano aiuta a caricare il codice e a fare il deploy mentre Passeggero Phusion è un modulo Apache che ci aiuta a distribuire un'applicazione rails su Apache in modo semplice.

L'installazione degli strumenti è illustrata di seguito:

Passi per installare la gemma Capistrano

#sudo gem installare capistrano

Questo comando installa la gemma Capistrano e si può iniziare a usare lo strumento Capistrano nella propria applicazione rails per distribuirla sul server.

Passi per installare Phusion passenger

#su -

Per installare il passeggero Phusion è necessario disporre dei permessi di root perché alcuni file utilizzati per l'installazione devono essere compilati, il che richiede i permessi di root.

#gem installare il passeggero

Questo comando installa il gemma Passenger. Non è necessario che Passenger sia installato nel nostro sistema locale per poterlo utilizzare. È necessario che Passenger sia installato nel sistema del server in cui verrà distribuita l'applicazione. Poiché Passenger è un modulo Apache, dobbiamo installare il modulo apache per esso, usando il seguente comando.

#passenger-installare-apache2-modulo

Questo comando installa il modulo Apache per lo strumento Passenger. Durante l'installazione, controlla i vari requisiti, a differenza dell'installazione della gemma Capistrano.

Ci sono delle dipendenze che devono essere installate per installare il modulo Passenger Apache. Non dobbiamo preoccuparci molto delle dipendenze, perché il processo di installazione controlla da solo la disponibilità delle dipendenze e, se non sono disponibili, ci darà i comandi per installarle. È sufficiente seguire le istruzioni fornite e Passenger sarà installato e pronto all'uso. Durante l'installazione ci chiede di aggiungere del codice al file di configurazione di Apache, come indicato di seguito:

LoadModule passenger_module /somewhere/passenger-x.x.x/ext/apache2/mod_passenger.so PassengerRuby /usr/bin/ruby PassengerRoot /somewhere/passenger/x.x.x PassengerMaxPoolSize 10

Se non si desidera installare queste dipendenze e si interrompe nel mezzo, l'installazione termina perché Passenger non può funzionare senza queste dipendenze. Si noti che Passenger deve essere installato solo sul server e non sul sistema locale. Una volta installati questi due strumenti, insieme ci forniscono un modo molto flessibile e semplice per distribuire l'applicazione rails su un numero qualsiasi di server alla volta.

Per utilizzare Capistrano per distribuire l'applicazione, è necessario creare un'applicazione con questo comando:

../rails_app # capify

Capistrano legge le istruzioni da un capfile e le elabora come indicato in esso. Il capfile è il file in cui si indicano a Capistrano tutti i server a cui ci si vuole connettere e i compiti che si vogliono eseguire su tali server. Il capfile contiene uno script Ruby, arricchito da un'ampia serie di sintassi di aiuto che facilitano la definizione dei ruoli e dei compiti dei server. Il codice di esempio del capfile sarà simile a questo:

role :libs, “crimson.capify.org”, “magenta.capify.org” role :files, “fuchsia.capify.org” task :search_libs, :roles => :libs do run “ls -x1 /usr/lib | grep -i xml” end task :count_libs, :roles => :libs do run “ls -x1 /usr/lib | wc -l” end desc “Collegamento al database di produzione.yml” task :link_production_db eseguire “ln -nfs #{deploy_to}/shared/config/database.yml #{release_path}/config/database.yml” fine

Quando si utilizza Capistrano è necessario impostare la struttura dell'applicazione utilizzando il comando seguente:

../rails_app # cap deploy:setup

Quando eseguiamo questo comando nella nostra applicazione, Capistrano configura la struttura dell'applicazione. L'applicazione dopo il deploy avrà cartelle con nomi come shared, releases e un link simbolico chiamato current che punta all'ultimo codice dell'ultima release nella cartella releases.

Ogni volta che modifichiamo o aggiorniamo il codice e lo rilasciamo tramite Capistrano, esso aggiungerà la nuova cartella alla cartella dei rilasci con il numero di versione del rilascio (il numero di versione sarà basato sul timestamp). Il link simbolico corrente punterà all'ultima release che contiene il codice più recente.

I compiti scritti in Capfile sono leggibili e sono molto facili da scrivere per chi sa lavorare con la riga di comando di Linux. Per vedere quali sono i task presenti nel file Capfile si deve usare questo comando che mostra i dati autodocumentati:

#cap -T o cap -vT

(-v è per le descrizioni verbose)

Viene visualizzato l'elenco dei compiti con le relative descrizioni, come indicato di seguito:

cap deploy # Distribuisce il progetto. cap deploy:check # Verifica le dipendenze del deploy. cap deploy:cleanup # Pulisce i vecchi rilasci. cap deploy:migrate # Esegue il task rake migrate. cap deploy:pending # Visualizza i commit dall'ultimo deploy.

Si consideri che si è scritto lo script ruby in capfile per distribuire l'applicazione. Ora, se si vuole distribuire l'applicazione, è necessario eseguire questo script dal prompt dei comandi:

# schieramento del tappo

In base ai dettagli dei server e al percorso dell'applicazione specificato nel capfile, Capistrano distribuirà l'applicazione. Se si stanno eseguendo server di applicazioni mongrel per ogni applicazione, è necessario scrivere il comando per avviare il server mongrel come task nel capfile.

Se si utilizza Phusion passenger per l'esecuzione di un'applicazione, è necessario aggiungere al capfile l'attività di avvio e riavvio dell'applicazione utilizzando Phusion passenger.

Desc “Avviare l'applicazione” task :start do eseguire “touch #{current_path}/tmp/restart.txt” end desc “Riavviare l'applicazione” task :restart do eseguire “touch #{current_path}/tmp/restart.txt” end

L'ambiente predefinito in cui Phusion passenger esegue l'applicazione è quello di produzione; se vogliamo cambiare l'ambiente, dobbiamo modificare RAILS_ENV nel file di ambiente.

Quando si utilizza Phusion passenger, che viene eseguito come modulo Apache, esso esegue il server di spawn per l'applicazione e a ogni riavvio esegue lo spawn del server con una nuova istanza. Utilizzando Phusion passenger è possibile distribuire l'applicazione a un URI di host virtuale. Per questo è necessario aggiungere la voce host virtuale nel file di configurazione di Apache, come mostrato nel codice di esempio qui sotto:

ServerName www.domain-name.com DocumentRoot /webapps/rails_app/public Consenti da tutti Opzioni -MultiViews

A tal fine, è necessario tenere conto delle seguenti condizioni:

*La radice dei documenti dell'host virtuale deve puntare al proprio sito web Rubino sui binari la cartella pubblica dell'applicazione. *I permessi per directory di Apache devono consentire l'accesso a questa cartella. *MultiViews deve essere disabilitato per questa cartella.

Se si vuole distribuire su un sub_URI, considerando che abbiamo già un host virtuale, dobbiamo aggiungere il codice come mostrato di seguito:

ServerName www.domain-name.com DocumentRoot /websites/phusion Consenti da tutti RailsBaseURI /rails Opzioni -MultiViews

E se volete che il vostro Applicazione Ruby on Rails per essere accessibile da un URL come http://www.domain-name.com/rails, è necessario creare un link simbolico dalla cartella pubblica dell'applicazione Ruby on Rails a una cartella nella radice del documento.

Per esempio:

#ln -s /webapps/rails-app/public /websites/phusion/rails

Una volta creato questo collegamento simbolico, si dovrà riavviare Apache e l'applicazione sarà stata distribuita. È possibile distribuire più applicazioni rails sotto un host virtuale, specificando più volte RailsBaseURI.

Una volta avviata l'applicazione, se si desidera riavviarla è necessario eseguire una di queste operazioni:

a) Riavviare il server web Apache. b) Utilizzare il comando

# toccare ../path_to_app/rails_app/tmp/restart.txt

Poiché stiamo usando Phusion passenger, che è un modulo di Apache, il log dell'esecuzione sarà registrato sia in Apache error_logs che nel file di log dell'applicazione. A volte questi log non vengono registrati nel log delle applicazioni Rails. In questo caso, è necessario controllare i permessi e risolvere il problema variando i permessi del file di log.

Quando si utilizza Capistrano con Phusion passenger, è possibile eseguire il deploy su più server alla volta e persino avviare e riavviare l'applicazione in un'unica esecuzione. In questo modo, è molto più facile distribuire un'applicazione Applicazione delle rotaie utilizzando Capistrano e Phusion passenger.

Mettiti in contatto con noi.