Comment utiliser JRuby pour exécuter une application Rails sur Apache Tomcat 7 et Ubuntu 14.04

introduction

Ruby on Rails (RoR) est un framework très populaire qui permet aux développeurs de créer rapidement des applications Web qui respectent les modèles de conception modernes. En utilisant Rails, avec seulement quelques commandes, vous pouvez créer une application CRUD (Créer, Lire, Mettre à jour, Supprimer) vanille prête à la production sans avoir à écrire du code. Apache Phusion Passenger, Unicorn et Puma sont quelques-uns des serveurs populaires utilisés pour exécuter les applications Rails.

Les performances de Ruby MRI se sont considérablement améliorées au fil des ans. Cependant, il est encore lent comparé à des langages comme Java ou C. Si vous souhaitez des temps d’écriture plus rapides, nécessaires pour les applications critiques, concurrentes, distribuées et de niveau entreprise, vous devez utiliser * JRuby * à la place, une implémentation Java de Ruby.

Quelques avantages de JRuby sur Ruby MRI

Concurrence * - Ruby MRI utilise GIL (Global Interpreter Lock), et par conséquent, la concurrence est limitée. JRuby, d’autre part, est capable d’utiliser les threads de la JVM, ce qui vous permet d’atteindre des niveaux beaucoup plus élevés de simultanéité. C’est généralement la raison la plus importante pour laquelle JRuby est choisi par rapport aux autres rubis.
Sécurité des threads * - La plupart des classes de base de Ruby ne sont pas thread-safe. L’utilisation de telles classes dans des applications multithreads est sujette aux erreurs. JRuby est capable d’utiliser les classes de Java, conçues pour le traitement parallèle.
Plus de bibliothèques * - Lorsque vous utilisez JRuby, vous disposez non seulement d’un répertoire de gemmes Ruby, mais également de toutes les bibliothèques Java et Scala. Cela vous permet de vous concentrer davantage sur les fonctionnalités principales de votre application.
Facilité de déploiement * - Une application JRuby on Rails peut être regroupée dans un seul fichier WAR, qui peut être déployé de manière triviale sur tout serveur Java EE. Beaucoup d’entre eux ont même des interfaces basées sur un navigateur pour gérer les applications.

Ce que couvre ce tutoriel

Dans ce tutoriel, vous apprendrez à:

Créez une application CRUD simple avec Rails (une application utilisant Ruby MRI)
Convertissez notre application Ruby on Rails en une application JRuby on Rails
Générer un fichier WAR pour l’application
Installer Apache Tomcat 7
Déployer le fichier WAR sur le serveur Tomcat

À la fin du didacticiel, vous aurez une application JRuby on Rails opérationnelle déployée.

Conditions préalables

Déployez un droplet * 32 bits Ubuntu 14.04 *. Tomcat et JRuby fonctionneront sur un serveur 64 bits, mais seront probablement plus lents.
Créez un utilisateur sudo.
Si votre Droplet dispose de moins de 2 Go de RAM, vous devez ajouter au moins 1 Go d’espace de permutation. Reportez-vous au didacticiel suivant pour plus d’informations: Comment ajouter un échange sur Ubuntu 14.04.
Installez la dernière version de RVM sur votre machine. Reportez-vous à la première étape du didacticiel suivant: 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 [Comment installer Ruby sur des rails sur Ubuntu 12.04 LTS (Precious Pangolin) avec RVM]. Vous devrez peut-être ajouter la clé avant de pouvoir installer RVM:

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

Suivez ce tutoriel via la commande.

Étape 1 - Créer une application CRUD RoR simple

Initialiser RVM. Cette initialisation est nécessaire pour chaque nouveau terminal que vous ouvrez.

. ~/.rvm/scripts/rvm

_ * Remarque *: Si vous possédez déjà une application Rails utilisant Ruby 1.9.3, vous pouvez désormais passer à l’étape 2. _

Créez un répertoire pour héberger toutes vos applications Rails et entrez-le.

mkdir ~/my_applications
cd ~/my_applications

Nous utilisons Ruby 1.9.3 pour ce didacticiel, car il s’agit de la dernière version de Ruby prise en charge par JRuby.

rvm install 1.9.3
rvm use 1.9.3

Installer des rails.

gem install rails -N

Créez une nouvelle application Rails, appelée * simple *.

rails new simple

Entrez le répertoire de l’application.

cd ~/my_applications/simple

Utilisez * nano * pour éditer et décommenter la ligne pour la gemme * therubyracer *. Ce joyau doit être ajouté car notre application Rails nécessite un runtime JavaScript.

nano ~/my_applications/simple/Gemfile

En ignorant les commentaires, votre fichier mis à jour devrait ressembler à ceci:

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

Vous voudrez supprimer la partie `+, plateformes: ruby ` de la ligne ` therubyracer +` commentée, car nous utiliserons finalement JRuby plutôt que Ruby.

Installez toutes les gemmes énumérées dans le.

bundle install

Ajoutez quelques pages à l’application à l’aide de la fonction d’échafaudage de Rails.

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

La commande + rails g scaffold + génère quelques migrations. Appliquez-les:

rake db:migrate

Modifiez la racine de l’application pour afficher la liste de tous les employés. Utilisez * nano * pour éditer + ~ / my_applications / simple / config / routes.rb + et changer son contenu comme suit: moins les commentaires:

Rails.application.routes.draw do
 resources :employees

end

Votre application Rails utilisant Ruby MRI est maintenant prête. Exécutez-le sur le serveur de développement en tapant:

rails s

Cela prendra une minute ou deux pour démarrer.

Vous pouvez visiter l’application dans votre navigateur en visitant * http: // <serveur-IP>: 3000 *. Créez quelques enregistrements pour vous assurer que tout fonctionne comme prévu.

image: http: //i.imgur.com/dTBCir9.png [Application fonctionnant sur le serveur Ruby MRI WEBrick]

Revenez sur votre console et arrêtez le serveur en appuyant sur * Ctrl + C *.

Étape 2 - Installez Java 8

Pour installer et utiliser JRuby, un JDK est requis. Vous pouvez installer Oracle JDK 8 après avoir ajouté le PPA + webupd8team / java.

Ajoutez le référentiel en tapant ce qui suit:

sudo add-apt-repository ppa:webupd8team/java

Appuyez sur * Entrée * pour accepter le nouveau référentiel.

Mettre à jour les fichiers d’index des paquets.

sudo apt-get update

Installez Oracle JDK 8.

sudo apt-get install oracle-java8-installer

Remarque *: Vous serez invité à accepter un contrat de licence avant le début de l’installation.

image: http: //i.imgur.com/UpKz5IL.png [Page du contrat de licence d’Oracle]

Sélectionnez * <Ok> * et appuyez sur * Entrée *, puis sélectionnez * <Oui> * et appuyez sur * Entrée *.

Une fois l’installation terminée, exécutez la commande suivante:

java -version

Vous devriez pouvoir voir la sortie suivante, ce qui signifie que Java a été installé correctement:

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)

Étape 3 - Installer JRuby et JRuby sur des rails

Utilisez RVM pour installer et utiliser JRuby.

rvm install jruby
rvm use jruby

La dernière version de JRuby (version 1.7.16.1 de novembre 2014) est maintenant prête à être utilisée. Vérifiez la version:

jruby -v

Cela montre que votre serveur utilise Oracle JDK 8. Vous devriez voir une sortie semblable à ceci:

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]

Installez JRuby sur les rails.

gem install rails -N

JRuby on Rails est maintenant installé.

Étape 4 - Configurez l’application pour qu’elle utilise JRuby

JRuby prend en charge de manière transparente bon nombre de gemmes Ruby MRI, mais il n’en existe pas d’autres avec un code natif. La plupart des gemmes qui sont des interfaces avec des bases de données entrent dans cette catégorie. Notre application utilise actuellement la gem * sqlite3 *, qui n’est pas prise en charge par JRuby. * activerecord-jdbcsqlite3-adapter * doit être utilisé à la place.

De même, JRuby utilise * therubyrhino * à la place du * therubyracer * gem en tant que moteur JavaScript.

Utilisez * nano * pour éditer + ~ / my_applications / simple / Gemfile + pour effectuer ce changement.

nano ~/my_applications/simple/Gemfile

Votre fichier devrait ressembler à ceci après la mise à jour des deux lignes, moins les commentaires:

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

Si vous ne le faisiez pas auparavant, vous devez maintenant supprimer le paramètre + platform de la ligne.

Certaines de nos pierres précieuses nécessitent des extensions natives. Tapez ce qui suit pour permettre à JRuby de prendre en charge les extensions C.

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

Vous pouvez maintenant installer les gemmes nouvellement ajoutées.

bundle install

Si vous n’utilisez pas SQLite3 en tant que base de données, vous aurez peut-être besoin de l’un de ces gems:

Pour Derby: * activerecord-jdbcderby-adapter *
Pour MySQL: * activerecord-jdbcmysql-adapter *
Pour Postgres: * activerecord-jdbcpostgresql-adapter *

Étape 5 - Mise à jour des fichiers de règles Java

À l’aide d’un navigateur, téléchargez les JCE Fichiers de règles de compétence en compétence illimitée. Vous devrez d’abord accepter le contrat de licence d’Oracle.

(Vous ne pouvez pas utiliser les fichiers car vous devez accepter les termes du contrat.)

Sur votre * ordinateur local *, téléchargez le fichier sur votre serveur à l’aide de * scp *:

scp jce_policy-8.zip @:~

Sur votre * serveur *, installez l’utilitaire de décompression:

sudo apt-get install unzip

Décompressez le fichier dans un répertoire dans.

cd /tmp
unzip ~/jce_policy-8.zip

Copiez les fichiers de règles dans le répertoire du JRE.

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

Retournez au répertoire de votre application.

cd ~/my_applications/simple

Exécutez la commande suivante pour accélérer le démarrage de la machine virtuelle Java. Cela est nécessaire car les environnements de serveur virtuel ont tendance à générer très peu d’aléatoire par eux-mêmes.

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

À ce stade, notre application Rails est entièrement configurée pour utiliser JRuby. Démarrer le serveur de développement:

rails s

Ce serveur peut prendre plusieurs secondes pour démarrer. Attendez de voir la sortie suivante avant de continuer:

=> 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

Utilisez un navigateur pour visiter * http: // <ip-serveur>: 3000 * et tester votre application. Hormis le fait qu’elle est en cours d’exécution sur la machine virtuelle Java au lieu d’utiliser Ruby MRI, vous ne devriez trouver aucune différence avec l’application.

Revenez au terminal et appuyez sur * Ctrl + C * pour arrêter le serveur.

Étape 6 - Compressez l’application en tant que fichier WAR déployable

Pour exécuter l’application JRuby on Rails sur un conteneur de servlets tel que Tomcat, vous devez d’abord l’intégrer dans un fichier WAR (Web application ARchive). Cela peut être fait en utilisant le * warbler * gem.

Installez * warbler *.

gem install warbler

La base de données SQLite utilisée par notre application est actuellement présente dans le répertoire de l’application. Lorsque le fichier WAR est généré, la base de données dans son état actuel sera placée dans le fichier WAR. Nous ne le souhaitons pas, car toutes les modifications apportées à la base de données après le déploiement seront écrasées si l’application est redéployée.

Par conséquent, les fichiers de base de données SQLite doivent être déplacés vers un emplacement situé en dehors du répertoire de l’application.

Créez un nouveau répertoire pour les bases de données:

mkdir -p ~/databases/simple

Dans ce tutoriel, nous ne nous intéressons qu’à la base de développement. Par conséquent, déplacez le fichier de base de données de développement vers le répertoire nouvellement créé:

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

Editez le fichier avec * nano *.

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

Mettez à jour le chemin de la base de développement. Vous pouvez également supprimer les détails pour d’autres environnements, car vous n’en aurez pas besoin pour ce tutoriel. Après les modifications, votre fichier devrait ressembler à ceci:

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

development:
 <<: *default
 database:

La Paruline a également besoin de connaître l’environnement Rails de la WAR. Dans ce tutoriel, nous nous en tenons à l’environnement. Ceci est spécifié en utilisant un fichier + config / warble.rb +.

Utilisez * nano * pour créer un nouveau fichier nommé

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

Ajoutez ce qui suit au fichier:

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

Notre application est maintenant prête à être intégrée dans un fichier WAR. Exécutez la commande suivante pour générer le fichier:

warble executable war

Cela prendra quelques instants.

La sortie réussie devrait ressembler à ceci:

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

À ce stade, un fichier sera nommé dans le répertoire de votre application. L’ajout de l’argument à la commande génère un fichier WAR contenant un petit serveur intégré (appelé Winstone). Ce fichier peut être utilisé indépendamment (sans serveur externe) comme suit:

java -jar simple.war

C’est un bon moyen de vérifier si vous rencontrez des problèmes avec votre fichier WAR. Vous pouvez maintenant utiliser un navigateur pour visiter * http: // <ip-serveur>: 8080 *. Au bout de quelques minutes, votre application devrait pouvoir fonctionner correctement. Toutes les entrées que vous avez faites précédemment dans l’application de base de données devraient être visibles ici.

Vous devez attendre que la sortie soit similaire à celle ci-dessous pour vous informer que le serveur a démarré:

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

Revenez au terminal et appuyez sur * Ctrl + C * pour arrêter le serveur intégré.

Maintenant que vous avez confirmé que l’application fonctionne en tant que fichier WAR, générez un nouveau fichier WAR pour Tomcat à l’aide de la commande suivante:

warble war

Il remplacera l’ancien WAR exécutable par un nouveau fichier WAR ne contenant aucun serveur intégré.

Étape 7 - Installer et démarrer Tomcat

Téléchargez la dernière version de Tomcat.

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

Créez un nouveau répertoire pour Tomcat et entrez-le.

mkdir ~/Tomcat
cd ~/Tomcat

Extraire l’archive:

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

Définissez la taille de segment maximale disponible pour Tomcat sur * 512m * pour éviter + java.lang.OutOfMemoryError +. Cette exportation doit être effectuée chaque fois que vous démarrez le serveur Tomcat.

export CATALINA_OPTS="-Xmx512m"

Comme auparavant, définissez la génération d’aléatoire:

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

Démarrer Tomcat:

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

Ce serveur prend également plusieurs secondes pour démarrer. Pour surveiller ses journaux, tapez:

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

Lorsque le serveur est prêt, vous verrez des messages de journal comme ceux-ci:

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

Appuyez sur * Ctrl + C * pour mettre fin à la commande.

Tomcat est maintenant installé et en cours d’exécution. Vous pouvez utiliser un navigateur pour visiter * http: // <ip-serveur>: 8080 *. Vous devriez pouvoir voir la page d’accueil de Tomcat.

image: http: //i.imgur.com/AStL4HY.png [Page d’accueil d’Apache Tomcat]

Étape 8 - Déployer l’application sur Tomcat

Pour déployer un fichier WAR sur Tomcat, il vous suffit de le copier dans le dossier de Tomcat.

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

Cela peut prendre une minute ou deux pour que votre application soit automatiquement déployée. Pendant que vous attendez, vous pouvez surveiller le contenu du fichier journal de Tomcat en utilisant:

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

Lorsque votre application est prête à être utilisée, vous verrez des messages de journal comme ceux-ci:

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

Appuyez sur * Ctrl + C * pour mettre fin à la commande + tail +.

Vous pouvez maintenant utiliser un navigateur pour visiter * http: // <ip-serveur>: 8080 / simple / * et voir votre application JRuby on Rails s’exécuter sur Tomcat.

Redémarrer votre session

Si vous vous déconnectez de votre session SSH à tout moment, vous devez exécuter les trois commandes suivantes:

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

Et si vous devez redémarrer Tomcat, exécutez les trois commandes précédentes et assurez-vous de définir les deux variables d’environnement avant de démarrer le serveur:

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

Conclusion

Ainsi, une application Ruby on Rails peut être convertie en une application JRuby on Rails avec seulement quelques modifications de configuration. Les applications JRuby on Rails peuvent s’exécuter sur presque tous les conteneurs de servlets. Dans ce tutoriel, vous avez déjà vu comment en exécuter un sur Apache Tomcat et Winstone.

TOC