Installera Rails Application med Capistrano och Phusion Passenger

Att distribuera en rails-applikation på servrarna är en komplicerad uppgift när den utförs manuellt, eftersom den kräver att vi loggar in på servrarna, laddar upp koden från det lokala systemet varje gång och underhåller säkerhetskopian av uppdateringarna om vi vill återgå.

Processen tar mycket tid och vi måste stoppa, starta och starta om applikationsservrarna varje gång vi behöver uppdatera. Denna uppgift kan förenklas med dessa två distributionsverktyg, dvs Capistrano och Phusion passagerare (även kallad "mod_rails").

Installationsproceduren för båda verktygen är ganska densamma, eftersom båda verktygen är installerade som Rails ädelstenar. Det är specialiteten hos Räls ramverk att den har alla nödvändiga verktyg för att bygga som ädelstenar.

Men skillnaden är att Capistrano hjälper till att ladda upp koden och distribuera Phusion passagerare är en Apache-modul som hjälper oss att distribuera en rails-applikation på Apache enkelt.

Installationen av verktygen är som visas nedan:

Steg för att installera Capistrano gem

#sudo gem installera capistrano

Detta kommando installerar Capistrano pärla och du kan börja använda verktyget Capistrano i din rails-applikation för att distribuera det till servern.

Steg för att installera Phusion passagerare

#su –

För att installera Phusion-passageraren måste vi ha root-behörigheter eftersom vissa filer som används för att installera den behöver kompileras vilket kräver root-behörigheter.

#gem installera passagerare

Detta kommando installerar Passenger pärla. Vi behöver inte Passenger installeras i vårt lokala system för att kunna använda det. Vi behöver Passageraren installerad i serversystemet där vi ska distribuera applikationen. Eftersom Passenger är en Apache-modul måste vi installera apache-modulen för den med följande kommando.

#passenger-install-apache2-modul

Detta kommando installerar Apache-modulen för passagerarverktyget. När du installerar detta kontrollerar den de olika kraven till skillnad från installationen av Capistrano pärla.

Det finns beroenden som måste installeras för att installera Passenger Apache-modulen. Vi behöver inte oroa oss mycket för beroenden eftersom installationsprocessen i sig själv kontrollerar tillgängligheten för beroenden och om de inte är tillgängliga kommer den att ge oss kommandon för att installera beroenden. Vi behöver bara följa instruktionerna den ger och Passenger kommer att vara installerad och redo att användas. Under installationen ber den oss att lägga till lite kod till Apache-konfigurationsfilen enligt nedan:

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

Om vi inte vill installera dessa beroenden och avbryta i mitten så avslutas installationen eftersom Passageraren inte kan köra utan dessa beroenden. Observera att vi bara behöver Passenger installerat på servern och behöver det inte vårt lokala system. När dessa två verktyg väl är installerade ger de oss tillsammans ett mycket flexibelt och enkelt sätt att distribuera rails-applikationen till valfritt antal servrar åt gången.

För att använda Capistrano för att distribuera din applikation måste du kapifiera din applikation med det här kommandot:

../rails_app # capify

Capistrano läser instruktioner från en capfil och bearbetar dem som de ges i den. Capfile är där du kommer att berätta för capistrano om alla servrar du vill ansluta till och de uppgifter du vill utföra på dessa servrar. Capfilen innehåller ett Ruby-skript med en stor uppsättning hjälpsyntax för att göra det enkelt att definiera serverroller och uppgifter. Exempelkoden för capfilen kommer att se ut så här:

role :libs, “crimson.capify.org”, “magenta.capify.org” role :files, “fuchsia.capify.org” uppgift :search_libs, :roles => :libs kör “ls -x1 /usr/lib | grep -i xml” slutuppgift :count_libs, :roles => :libs kör “ls -x1 /usr/lib | wc -l" end desc "Länk i produktionsdatabasen.yml" uppgift :link_production_db kör "ln -nfs #{deploy_to}/shared/config/database.yml #{release_path}/config/database.yml" end

När vi använder Capistrano måste vi ställa in strukturen för applikationen med kommandot nedan:

../rails_app # cap deploy:setup

När vi kör det här kommandot i vår applikation kommer Capistrano att ställa in applikationsstrukturen. Applikationen kommer efter implementeringen att ha mappar med namn som delade, utgåvor och en symbolisk länk som kallas aktuell som pekar på den senaste koden för den senaste utgåvan i utgivningsmappen.

Närhelst vi ändrar eller uppdaterar koden och vi släpper genom Capistrano kommer den att lägga till den nya mappen i releasemappen med versionsnumret (versionsnumret kommer att baseras på tidsstämpeln). Den aktuella sym-länken kommer att peka på den senaste versionen som innehåller den senaste koden.

Uppgifterna skrivna i Capfile är läsbara och det är mycket lätt att skriva dessa för en person som kan arbeta med kommandorads Linux-skal. För att se vilka uppgifter som finns i capfilen bör vi använda det här kommandot som visar de självdokumenterade data:

#cap -T eller cap -vT

(-v är för utförliga beskrivningar)

Detta visar listan med uppgifter tillsammans med beskrivningarna enligt nedan:

cap deploy # Distribuerar ditt projekt. cap deploy:check # Testa distributionsberoenden. cap deploy:cleanup # Rensa upp gamla utgåvor. cap deploy:migrate # Kör migrate rake-uppgiften. cap deploy:pending # Visar commits sedan din senaste implementering.

Tänk på att du har skrivit ruby-skriptet i capfile för att distribuera programmet. Om du nu vill distribuera programmet måste du köra detta vid kommandotolken:

# cap utplacering

Sedan kommer Capistrano att distribuera applikationen enligt detaljerna för servrarna och sökvägen för applikationen som anges i capfilen. Om du kör mongrel-applikationsservrar för varje applikation måste du skriva kommandot för att starta mongrel-servern som en uppgift i capfilen.

Anta att du använder Phusion passagerare för att köra applikationen så måste du lägga till uppgiften att starta och starta om applikationen med Phusion passagerare i capfilen.

Beskriv "Starta applikation" uppgift :starta köra "touch #{current_path}/tmp/restart.txt" slut desc "Starta om applikation" uppgift :starta om kör "touch #{current_path}/tmp/restart.txt" slut

Standardmiljön som Phusion-passageraren kör applikationen på är produktion, om vi vill ändra miljön måste vi modifiera RAILS_ENV i miljöfilen.

När du använder Phusion passagerare som körs som en Apache-modul, kör den spawn-servern för applikationen och vid varje omstartsoperation genererar den servern med en ny instans. Med Phusion passagerare kan du distribuera applikationen till en virtuell värd-URI. För detta måste du lägga till den virtuella värdposten i Apache-konfigurationsfilen som visas i exempelkoden nedan:

Servernamn www.domännamn.com DocumentRoot /webapps/rails_app/public Tillåt från alla alternativ -MultiViews

När vi gör detta måste vi ta hand om följande villkor:

*Den virtuella värdens dokumentrot måste peka på din Ruby on Rails programmets offentliga mapp. *Apache-behörigheterna per katalog måste tillåta åtkomst till denna mapp. *MultiViews måste inaktiveras för den här mappen.

Om du vill distribuera till en sub_URI, med tanke på att vi redan har en virtuell värd måste vi lägga till koden enligt nedan:

Servernamn www.domännamn.com DocumentRoot /webbplatser/phusion Tillåt från alla RailsBaseURI /rails-alternativ -MultiViews

Och om du vill ha din Ruby on Rails-applikation för att vara tillgänglig från någon URL som http://www.domain-name.com/rails måste du skapa en symbollänk från din Ruby on Rails-applikations publika mapp till en katalog i dokumentroten.

Till exempel:

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

När du har skapat den här symboliska länken måste du starta om Apache och applikationen kommer att ha distribuerats. Du kan distribuera flera rails-applikationer under en virtuell värd genom att ange RailsBaseURI flera gånger.

När applikationen har startat, om vi vill starta om applikationen måste vi göra någon av dessa saker:

a) Starta om Apache-webbservern. b) Använd kommandot

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

Eftersom vi använder Phusion passagerare som är en Apache-modul kommer den löpande loggen att loggas i både Apache error_logs och applikationsloggfilen. Ibland kommer dessa inte att loggas i Rails-applikationsloggen. I så fall måste du kontrollera behörigheterna och åtgärda det här problemet genom att variera behörigheterna för loggfilen.

När du använder Capistrano med Phusion passagerare kan du distribuera till mer än en server åt gången och till och med starta och starta om programmet i en enda körning. Således är det mycket lättare att distribuera en Rails ansökan använder Capistrano och Phusion passagerare.

Kontakta oss.