Verwendung von JRuby zum Ausführen einer Rails-Anwendung unter Apache Tomcat 7 und Ubuntu 14.04

Einführung

Ruby on Rails (RoR) ist ein sehr beliebtes Framework, mit dem Entwickler schnell Webanwendungen erstellen können, die modernen Entwurfsmustern entsprechen. Mit Rails können Sie mit wenigen Befehlen eine produktionsbereite Vanille-CRUD-Anwendung (Erstellen, Lesen, Aktualisieren, Löschen) erstellen, ohne Code schreiben zu müssen. Apache Phusion Passenger, Unicorn und Puma sind einige der beliebtesten Server, auf denen Rails-Anwendungen ausgeführt werden.

Die Leistung der Ruby-MRT hat sich im Laufe der Jahre erheblich verbessert. Es ist jedoch im Vergleich zu Sprachen wie Java oder C immer noch langsam. Wenn Sie an schnelleren Schreibzeiten interessiert sind, die für kritische, gleichzeitige, verteilte und Unternehmensanwendungen erforderlich sind, sollten Sie stattdessen * JRuby * verwenden, eine Java-Implementierung von Ruby.

Einige Vorteile von JRuby gegenüber der Ruby-MRT

Nebenläufigkeit * - Die Ruby-MRT verwendet GIL (Global Interpreter Lock) und weist folglich eine begrenzte Nebenläufigkeit auf. JRuby hingegen kann JVM-Threads verwenden, wodurch Sie viel höhere Ebenen der Parallelität erzielen. Dies ist normalerweise der wichtigste Grund, warum JRuby anderen Rubinen vorgezogen wird.
Thread-Sicherheit * - Die meisten Ruby-Kernklassen sind nicht thread-sicher. Die Verwendung solcher Klassen in Multithread-Anwendungen ist fehleranfällig. JRuby kann stattdessen Java-Klassen verwenden, die für die parallele Verarbeitung ausgelegt sind.
Weitere Bibliotheken * - Wenn Sie JRuby verwenden, steht Ihnen nicht nur ein Repertoire an Ruby-Edelsteinen zur Verfügung, sondern auch alle Java- und Scala-Bibliotheken. So können Sie sich mehr auf die Kernfunktionen Ihrer Anwendung konzentrieren.
Einfache Bereitstellung * - Eine JRuby on Rails-Anwendung kann in eine einzelne WAR-Datei gepackt werden, die problemlos auf jedem Java EE-Server bereitgestellt werden kann. Viele von ihnen verfügen sogar über browserbasierte Schnittstellen zur Verwaltung von Anwendungen.

Was dieses Tutorial behandelt

In diesem Tutorial lernen Sie:

Erstellen Sie eine einfache CRUD-Anwendung mit Rails (eine mit Ruby-MRT)
Konvertieren Sie unsere Ruby on Rails-Anwendung in eine JRuby on Rails-Anwendung
Generieren Sie eine WAR-Datei für die Anwendung
Installieren Sie Apache Tomcat 7
Stellen Sie die WAR-Datei auf dem Tomcat-Server bereit

Am Ende des Lernprogramms wird eine funktionierende JRuby on Rails-Anwendung bereitgestellt.

Voraussetzungen

Stellen Sie ein * 32-Bit-Ubuntu 14.04 * -Droplet bereit. Tomcat und JRuby werden auf einem 64-Bit-Server ausgeführt, sind jedoch wahrscheinlich langsamer.
Erstellen Sie einen sudo Benutzer.
Wenn Ihr Droplet weniger als 2 GB RAM hat, sollten Sie mindestens 1 GB Auslagerungsspeicher hinzufügen. Weitere Informationen finden Sie im folgenden Tutorial: How To Swap on Ubuntu 14.04.
Installieren Sie die neueste Version von RVM auf Ihrem Computer. Lesen Sie in Schritt 1 des folgenden Tutorials nach: https://www.digitalocean.com/community/tutorials/how-to-install-ruby-on-rails-on-ubuntu-12-04-lts-precise-pangolin-with -rvm # step-one% E2% 80% 94-install-ruby-with-rvm [Installieren von Ruby on Rails unter Ubuntu 12.04 LTS (Precise Pangolin) mit RVM]. Möglicherweise müssen Sie den Schlüssel hinzufügen, bevor Sie RVM installieren können:

gpg --keyserver hkp://keys.gnupg.net --recv-keys D39DC0E3

Folgen Sie diesem Tutorial durch den Befehl.

Schritt 1 - Erstellen Sie eine einfache CRUD RoR-Anwendung

RVM initialisieren. Diese Initialisierung ist für jedes neue Terminal erforderlich, das Sie öffnen.

. ~/.rvm/scripts/rvm

_ * Hinweis *: Wenn Sie bereits eine Rails-Anwendung haben, die Ruby 1.9.3 verwendet, können Sie jetzt mit Schritt 2 fortfahren. _

Erstellen Sie ein Verzeichnis für alle Ihre Rails-Anwendungen und geben Sie dieses Verzeichnis ein.

mkdir ~/my_applications
cd ~/my_applications

Wir verwenden Ruby 1.9.3 für dieses Tutorial, da dies die neueste Version von Ruby ist, die JRuby unterstützt.

rvm install 1.9.3
rvm use 1.9.3

Schienen installieren.

gem install rails -N

Erstellen Sie eine neue Rails-Anwendung mit dem Namen * simple *.

rails new simple

Geben Sie das Anwendungsverzeichnis ein.

cd ~/my_applications/simple

Verwenden Sie * nano *, um die Zeile für den Edelstein * therubyracer * zu bearbeiten und zu kommentieren. Dieses Juwel muss hinzugefügt werden, da unsere Rails-Anwendung eine JavaScript-Laufzeit benötigt.

nano ~/my_applications/simple/Gemfile

Wenn Sie die Kommentare ignorieren, sollte Ihre aktualisierte Datei folgendermaßen aussehen:

source 'https://rubygems.org'

gem 'rails', '4.1.7'
gem 'sqlite3'
gem 'sass-rails', '~> 4.0.3'
gem 'uglifier', '>= 1.3.0'
gem 'coffee-rails', '~> 4.0.0'

gem 'jquery-rails'
gem 'turbolinks'
gem 'jbuilder', '~> 2.0'
gem 'sdoc', '~> 0.4.0',          group: :doc
gem 'spring',        group: :development

Sie möchten den Teil "+, platform: ruby " der kommentierten Zeile " therubyracer +" entfernen, da wir schließlich JRuby anstelle von Ruby verwenden.

Installieren Sie alle in der aufgelisteten Edelsteine.

bundle install

Fügen Sie der Anwendung mithilfe der Rails-Gerüstfunktion einige Seiten hinzu.

rails g scaffold Employee name:string age:integer address:text

Der Befehl "+ Rails G Scaffold +" generiert einige Migrationen. Wende sie an:

rake db:migrate

Ändern Sie das Stammverzeichnis der Anwendung, um die Liste aller Mitarbeiter anzuzeigen. Verwenden Sie * nano *, um "+ ~ / my_applications / simple / config / routes.rb +" zu bearbeiten und den Inhalt in den unten gezeigten zu ändern, abzüglich der Kommentare:

Rails.application.routes.draw do
 resources :employees

end

Ihre Rails-Anwendung, die Ruby MRI verwendet, ist jetzt bereit. Führen Sie es auf dem Entwicklungsserver aus, indem Sie Folgendes eingeben:

rails s

Dies dauert ein bis zwei Minuten.

Sie können die Anwendung in Ihrem Browser aufrufen, indem Sie * http: // <Server-IP>: 3000 * aufrufen. Erstellen Sie einige Datensätze, um sicherzustellen, dass alles wie erwartet funktioniert.

image: http: //i.imgur.com/dTBCir9.png [Anwendung, die auf dem Ruby MRI WEBrick-Server ausgeführt wird]

Kehren Sie zu Ihrer Konsole zurück und stoppen Sie den Server, indem Sie * Strg + C * drücken.

Schritt 2 - Installieren Sie Java 8

Zur Installation und Verwendung von JRuby ist ein JDK erforderlich. Oracle JDK 8 kann nach dem Hinzufügen des PPA + webupd8team / java installiert werden.

Fügen Sie das Repository hinzu, indem Sie Folgendes eingeben:

sudo add-apt-repository ppa:webupd8team/java

Drücken Sie die Eingabetaste, um das neue Repository zu akzeptieren.

Aktualisieren Sie die Paketindexdateien.

sudo apt-get update

Installieren Sie Oracle JDK 8.

sudo apt-get install oracle-java8-installer

Hinweis *: Sie werden aufgefordert, eine Lizenzvereinbarung zu akzeptieren, bevor die eigentliche Installation beginnt.

image: http: //i.imgur.com/UpKz5IL.png [Oracle-Lizenzvereinbarungsseite]

Wählen Sie * <Ok> * und drücken Sie * Enter *, wählen Sie dann * <Yes> * und drücken Sie * Enter *.

Führen Sie nach Abschluss der Installation den folgenden Befehl aus:

java -version

Sie sollten die folgende Ausgabe sehen können, was bedeutet, dass Java korrekt installiert wurde:

java version "1.8.0_25"
Java(TM) SE Runtime Environment (build 1.8.0_25-b17)
Java HotSpot(TM) Client VM (build 25.25-b02, mixed mode)

Schritt 3 - Installieren Sie JRuby und JRuby auf Schienen

Verwenden Sie RVM, um JRuby zu installieren und zu verwenden.

rvm install jruby
rvm use jruby

Die neueste Version von JRuby (1.7.16.1, Stand November 2014) ist jetzt einsatzbereit. Überprüfe die Version:

jruby -v

Dies zeigt Ihnen, dass Ihr Server Oracle JDK 8 verwendet. Sie sollten eine Ausgabe ähnlich der folgenden sehen:

jruby 1.7.16.1 (1.9.3p392) 2014-10-28 4e93f31 on Java HotSpot(TM) Client VM 1.8.0_25-b17 +jit [linux-i386]

Installieren Sie JRuby on Rails.

gem install rails -N

JRuby on Rails ist jetzt installiert.

Schritt 4 - Konfigurieren Sie die Anwendung für die Verwendung von JRuby

Viele Ruby-MRT-Edelsteine werden von JRuby nahtlos unterstützt, einige Edelsteine mit nativem Code jedoch nicht. Die meisten Edelsteine, die Schnittstellen zu Datenbanken darstellen, fallen in diese Kategorie. Unsere Anwendung verwendet derzeit das * sqlite3 * -Edelstein, das von JRuby nicht unterstützt wird. Stattdessen sollte * activerecord-jdbcsqlite3-adapter * verwendet werden.

Ebenso verwendet JRuby * therubyrhino * anstelle des Edelsteins * therubyracer * als JavaScript-Engine.

Verwenden Sie * nano * zum Bearbeiten von + ~ / my_applications / simple / Gemfile +, um diese Änderung vorzunehmen.

nano ~/my_applications/simple/Gemfile

Ihre Datei sollte nach dem Aktualisieren der beiden Zeilen ohne die Kommentare folgendermaßen aussehen:

source 'https://rubygems.org'

gem 'rails', '4.1.7'
gem
gem 'sass-rails', '~> 4.0.3'
gem 'uglifier', '>= 1.3.0'
gem 'coffee-rails', '~> 4.0.0'
gem
gem 'jquery-rails'
gem 'turbolinks'
gem 'jbuilder', '~> 2.0'
gem 'sdoc', '~> 0.4.0',          group: :doc
gem 'spring',        group: :development

Wenn Sie dies zuvor nicht getan haben, müssen Sie jetzt die Einstellung "+ Plattform" von der Linie entfernen.

Einige unserer Edelsteine erfordern native Erweiterungen. Geben Sie Folgendes ein, damit JRuby C-Erweiterungen unterstützt.

echo "cext.enabled=true" >> ~/.jrubyrc

Sie können nun die neu hinzugefügten Edelsteine installieren.

bundle install

Wenn Sie SQLite3 nicht als Datenbank verwenden, benötigen Sie möglicherweise einen der folgenden Edelsteine:

Für Derby: * activerecord-jdbcderby-adapter *
Für MySQL: * activerecord-jdbcmysql-adapter *
Für Postgres: * activerecord-jdbcpostgresql-adapter *

Schritt 5 - Java-Richtliniendateien aktualisieren

Laden Sie in einem Browser die Richtliniendateien JCE Unlimited Strength Jurisdiction herunter. Sie müssen zuerst die Lizenzvereinbarung von Oracle akzeptieren.

(Sie können die Dateien nicht herunterladen, da Sie die Vereinbarung akzeptieren müssen.)

Laden Sie die Datei auf Ihrem * lokalen * Computer mit * scp * auf Ihren Server hoch:

scp jce_policy-8.zip @:~

Installieren Sie auf Ihrem * Server * das Dienstprogramm zum Entpacken:

sudo apt-get install unzip

Entpacke die Datei in ein Verzeichnis in.

cd /tmp
unzip ~/jce_policy-8.zip

Kopieren Sie die Richtliniendateien in das JRE-Verzeichnis.

cd /tmp/UnlimitedJCEPolicyJDK8
sudo cp *.jar /usr/lib/jvm/java-8-oracle/jre/lib/security/

Kehren Sie zum Verzeichnis Ihrer Anwendung zurück.

cd ~/my_applications/simple

Führen Sie den folgenden Befehl aus, um den JVM-Start zu beschleunigen. Dies ist erforderlich, da virtuelle Serverumgebungen für sich genommen in der Regel nur sehr wenig Zufälligkeit erzeugen.

export JAVA_OPTS="-Djava.security.egd=file:/dev/./urandom"

Zu diesem Zeitpunkt ist unsere Rails-Anwendung vollständig für die Verwendung von JRuby konfiguriert. Starten Sie den Entwicklungsserver:

rails s

Der Start dieses Servers kann einige Sekunden dauern. Warten Sie, bis die folgende Ausgabe angezeigt wird, bevor Sie fortfahren:

=> Booting WEBrick
=> Rails 4.1.7 application starting in development on http://0.0.0.0:3000
=> Run `rails server -h` for more startup options
=> Notice: server is listening on all interfaces (0.0.0.0). Consider using 127.0.0.1 (--binding option)
=> Ctrl-C to shutdown server
[2014-11-06 04:38:15] INFO  WEBrick 1.3.1
[2014-11-06 04:38:15] INFO  ruby 1.9.3 (2014-09-25) [java]
[2014-11-06 04:38:15] INFO  WEBrick::HTTPServer#start: pid=2620 port=3000

Rufen Sie mit einem Browser * http: // <server-ip>: 3000 * auf und testen Sie Ihre Anwendung. Abgesehen von der Tatsache, dass es derzeit auf der JVM ausgeführt wird, anstatt Ruby MRI zu verwenden, sollten Sie an der Anwendung nichts anderes feststellen.

Kehren Sie zum Terminal zurück und drücken Sie * Strg + C *, um den Server anzuhalten.

Schritt 6 - Packen Sie die Anwendung als bereitstellbare WAR-Datei

Um die JRuby on Rails-Anwendung auf einem Servlet-Container wie Tomcat auszuführen, muss sie zuerst in eine WAR-Datei (Web Application Archive) gepackt werden. Dies kann mit dem Edelstein * warbler * geschehen.

Installiere * warbler *.

gem install warbler

Die von unserer Anwendung verwendete SQLite-Datenbank befindet sich derzeit im Anwendungsverzeichnis. Wenn die WAR-Datei generiert wird, wird die Datenbank in ihrem aktuellen Status in die WAR-Datei eingefügt. Dies ist nicht erwünscht, da alle Änderungen, die nach der Bereitstellung an der Datenbank vorgenommen werden, überschrieben werden, wenn die Anwendung erneut bereitgestellt wird.

Daher sollten die SQLite-Datenbankdateien an einen Speicherort außerhalb des Anwendungsverzeichnisses verschoben werden.

Erstellen Sie ein neues Verzeichnis für die Datenbanken:

mkdir -p ~/databases/simple

In diesem Tutorial geht es nur um die Entwicklungsdatenbank. Verschieben Sie daher die Entwicklungsdatenbankdatei in das neu erstellte Verzeichnis:

mv ~/my_applications/simple/db/development.sqlite3 ~/databases/simple

Bearbeiten Sie die Datei mit * nano *.

nano ~/my_applications/simple/config/database.yml

Aktualisieren Sie den Pfad der Entwicklungsdatenbank. Sie können die Details auch für andere Umgebungen entfernen, da Sie sie für dieses Lernprogramm nicht benötigen. Nach den Änderungen sollte Ihre Datei folgendermaßen aussehen:

default: &default
 adapter: sqlite3
 pool: 5
 timeout: 5000

development:
 <<: *default
 database:

Warbler muss auch die Rails-Umgebung des WAR kennen. In diesem Tutorial halten wir uns an die Umwelt. Dies wird mit einer + config / warble.rb + Datei angegeben.

Verwenden Sie * nano *, um eine neue Datei mit dem Namen zu erstellen

nano ~/my_applications/simple/config/warble.rb

Fügen Sie der Datei Folgendes hinzu:

Warbler::Config.new do |config|
 config.webxml.rails.env =
end

Unsere Anwendung kann jetzt in eine WAR-Datei gepackt werden. Führen Sie den folgenden Befehl aus, um die Datei zu generieren:

warble executable war

Dies wird einige Momente dauern.

Eine erfolgreiche Ausgabe sollte folgendermaßen aussehen:

Downloading winstone-0.9.10-jenkins-43.jar
rm -f simple.war
Creating simple.war

Zu diesem Zeitpunkt befindet sich eine Datei im Verzeichnis Ihrer Anwendung. Durch Hinzufügen des Arguments zum Befehl wird eine WAR-Datei generiert, die einen winzigen eingebetteten Server (Winstone) enthält. Diese Datei kann unabhängig (ohne externen Server) wie folgt verwendet werden:

java -jar simple.war

Dies ist eine gute Möglichkeit, um nach Problemen mit Ihrer WAR-Datei zu suchen. Sie können jetzt mit einem Browser * http: // <server-ip>: 8080 * aufrufen. Nach einigen Minuten sollte Ihre Anwendung ordnungsgemäß funktionieren. Alle Einträge, die Sie zuvor in der Datenbankanwendung vorgenommen haben, sollten hier sichtbar sein.

Sie sollten warten, bis eine Ausgabe ähnlich der folgenden angezeigt wird, um mitzuteilen, dass der Server gestartet wurde:

Nov 13, 2014 12:24:37 PM winstone.Logger logInternal
INFO: Started GET "/assets/application.js?body=1" for 108.29.37.206 at 2014-11-13 12:24:37 -0500

Kehren Sie zum Terminal zurück und drücken Sie * Strg + C *, um den eingebetteten Server zu stoppen.

Nachdem Sie bestätigt haben, dass die Anwendung als WAR funktioniert, generieren Sie mit dem folgenden Befehl eine neue WAR für Tomcat:

warble war

Es ersetzt die alte ausführbare WAR-Datei durch eine neue WAR-Datei, die keinen eingebetteten Server enthält.

Schritt 7 - Tomcat installieren und starten

Laden Sie die neueste Version von Tomcat herunter.

cd ~
wget http://mirror.cc.columbia.edu/pub/software/apache/tomcat/tomcat-7/v7.0.56/bin/apache-tomcat-7.0.56.tar.gz

Erstellen Sie ein neues Verzeichnis für Tomcat und geben Sie dieses Verzeichnis ein.

mkdir ~/Tomcat
cd ~/Tomcat

Extrahieren Sie das Archiv:

tar -xvzf ~/apache-tomcat-7.0.56.tar.gz

Stellen Sie die maximale für Tomcat verfügbare Heap-Größe auf * 512m * ein, um "+ java.lang.OutOfMemoryError +" zu vermeiden. Dieser Export muss bei jedem Start des Tomcat-Servers durchgeführt werden.

export CATALINA_OPTS="-Xmx512m"

Stellen Sie wie bisher die Zufallsgenerierung ein:

export JAVA_OPTS="-Djava.security.egd=file:/dev/./urandom"

Starten Sie Tomcat:

~/Tomcat/apache-tomcat-7.0.56/bin/catalina.sh start

Auch dieser Server benötigt einige Sekunden zum Starten. Geben Sie zum Überwachen der Protokolle Folgendes ein:

tail -f ~/Tomcat/apache-tomcat-7.0.56/logs/catalina.out

Wenn der Server bereit ist, werden folgende Protokollmeldungen angezeigt:

Nov 10, 2014 4:12:32 AM org.apache.catalina.startup.HostConfig deployDirectory
INFO: Deployment of web application directory ~/Tomcat/apache-tomcat-7.0.56/webapps/manager has finished in 210 ms
Nov 10, 2014 4:12:32 AM org.apache.coyote.AbstractProtocol start
INFO: Starting ProtocolHandler ["http-bio-8080"]
Nov 10, 2014 4:12:32 AM org.apache.coyote.AbstractProtocol start
INFO: Starting ProtocolHandler ["ajp-bio-8009"]
Nov 10, 2014 4:12:32 AM org.apache.catalina.startup.Catalina start
INFO: Server startup in 3390 ms

Drücken Sie * Strg + C *, um den Befehl zu beenden.

Tomcat ist jetzt installiert und läuft. Sie können einen Browser verwenden, um * http: // <server-ip>: 8080 * aufzurufen. Sie sollten in der Lage sein, die Tomcat-Begrüßungsseite zu sehen.

image: http: //i.imgur.com/AStL4HY.png [Willkommensseite von Apache Tomcat]

Schritt 8 - Stellen Sie die Anwendung auf Tomcat bereit

Um eine WAR für Tomcat bereitzustellen, müssen Sie sie nur in den Tomcat-Ordner kopieren.

cp ~/my_applications/simple/simple.war ~/Tomcat/apache-tomcat-7.0.56/webapps

Es kann ungefähr eine Minute dauern, bis Ihre Anwendung automatisch bereitgestellt wird. Während Sie warten, können Sie den Inhalt der Tomcat-Protokolldatei folgendermaßen überwachen:

tail -f ~/Tomcat/apache-tomcat-7.0.56/logs/catalina.out

Wenn Ihre Anwendung zur Verwendung bereit ist, werden folgende Protokollmeldungen angezeigt:

INFO: Deploying web application archive ~/Tomcat/apache-tomcat-7.0.56/webapps/simple.war
Oct 30, 2014 4:42:35 AM org.apache.catalina.startup.HostConfig deployWAR
INFO: Deployment of web application archive ~/Tomcat/apache-tomcat-7.0.56/webapps/simple.war has finished in 47,131 ms

Drücken Sie * Strg + C *, um den Befehl + tail + zu beenden.

Sie können jetzt mit einem Browser * http: // <server-ip>: 8080 / simple / * aufrufen und sehen, wie Ihre JRuby on Rails-Anwendung auf Tomcat ausgeführt wird.

Sitzung neu starten

Wenn Sie zu irgendeinem Zeitpunkt die Verbindung zu Ihrer SSH-Sitzung trennen, sollten Sie die folgenden drei Befehle ausführen:

cd ~/my_applications/simple
. ~/.rvm/scripts/rvm
rvm use jruby

Wenn Sie Tomcat neu starten müssen, führen Sie die vorherigen drei Befehle aus und stellen Sie sicher, dass Sie die beiden Umgebungsvariablen festgelegt haben, bevor Sie den Server starten:

export CATALINA_OPTS="-Xmx512m"
export JAVA_OPTS="-Djava.security.egd=file:/dev/./urandom"
~/Tomcat/apache-tomcat-7.0.56/bin/catalina.sh start

Fazit

So kann eine Ruby on Rails-Anwendung mit wenigen Konfigurationsänderungen in eine JRuby on Rails-Anwendung umgewandelt werden. JRuby on Rails-Anwendungen können auf fast allen Servlet-Containern ausgeführt werden. In diesem Tutorial haben Sie bereits gesehen, wie Sie eines unter Apache Tomcat und Winstone ausführen.

TOC