Miles to go …

nginx (pronounced as “engine-ex”) is an open-source and high-performance HTTP server. It provides the common features such as reverse proxying with caching, load balancing, modular architecture using filters (gzipping, chunked responses, etc), virtual servers, flexible configuration and much more.

nginx is known for it’s high performance and low resource consumption. It’s a fairly popular front-end HTTP server in the Rails community along with Apache, Lighttpd, and others. This TOTD (Tip Of The Day) will show how to install/configure nginx for load-balancing/front-ending a cluster of Rails application running on GlassFish Gem.

1. Download, build, and install nginx using the simple script (borrowed from dzone):

   ~/tools > curl -L -O http://sysoev.ru/nginx/nginx-0.6.36.tar.gz ~/tools > tar -xzf nginx-0.6.36.tar.gz ~/tools > curl -L -O http://downloads.sourceforge.net/pcre/pcre-7.7.tar.gz ~/tools > tar -xzf pcre-7.7.tar.gz ~/tools/nginx-0.6.36 > ./configure –prefix=/usr/local/nginx –sbin-path=/usr/sbin –with-debug –with-http_ssl_module –with-pcre=../pcre-7.7 ~/tools/nginx-0.6.36 > make ~/tools/nginx-0.6.36 > sudo make install ~/tools/nginx-0.6.36 > which nginx /usr/sbin/nginx

   OK, nginx is now roaring and can be verified by visiting “http://localhost” as shown below:

   

2. Create a simple Rails scaffold as:
   

   ~/samples/jruby >~/tools/jruby/bin/jruby -S rails runner ~/samples/jruby/runner >~/tools/jruby/bin/jruby script/generate scaffold runlog miles:float minutes:integer ~/samples/jruby/runner >sed s/’adapter: sqlite3′/’adapter: jdbcsqlite3′/ <config/database.yml >config/database.yml.new ~/samples/jruby/runner >mv config/database.yml.new config/database.yml ~/samples/jruby/runner >~/tools/jruby/bin/jruby -S rake db:migrate

3. Run this application using GlassFish Gem on 3 separate ports as:
   

   ~/samples/jruby/runner >~/tools/jruby/bin/jruby -S glassfish Starting GlassFish server at: 192.168.1.145:3000 in development environment… Writing log messages to: /Users/arungupta/samples/jruby/runner/log/development.log. Press Ctrl+C to stop.

   The default port is 3000. Start the seond one by explicitly specifying the port using “-p” option ..

   ~/samples/jruby/runner >~/tools/jruby/bin/jruby -S glassfish -p 3001 Starting GlassFish server at: 192.168.1.145:3001 in development environment… Writing log messages to: /Users/arungupta/samples/jruby/runner/log/development.log. Press Ctrl+C to stop.

   and the last one on 3002 port …

   ~/samples/jruby/runner >~/tools/jruby/bin/jruby -S glassfish -p 3002 Starting GlassFish server at: 192.168.1.145:3002 in development environment… Writing log messages to: /Users/arungupta/samples/jruby/runner/log/development.log. Press Ctrl+C to stop.

   On Solaris and Linux, you can run GlassFish as a daemon as well.

4. Nginx currently uses a simple round-robin algorithm. Other load balancers such as nginx-upstream-fair (fair proxy) and nginx-ey-balancer (maximum connections) are also available. The built-in algorithm will be used for this blog. Edit “/usr/local/nginx/conf/nginx.conf” to specify an upstream module which provides load balancing:
   1. Create a cluster definition by adding an upstream module (configuration details) right before the “server” module:

      upstream glassfish {         server 127.0.0.1:3000;         server 127.0.0.1:3001;         server 127.0.0.1:3002;     }

      The cluster specifies a bunch of GlassFish Gem instances running at the backend. Each server can be weighted differently as explained here. The port numbers must exactly match as those specified at the start up. The modified “nginx.conf” looks like:

      

      The changes are highlighted on lines #35 through #39.

   2. Configure load balancing by specifying this cluster using “proxy_pass” directive as shown below:
      

      proxy_pass http://glassfish;

      in the “location” module. The updated “nginx.conf” looks like:

      

      The change is highlighted on line #52.

5. Restart nginx by using the following commands:
   

   sudo kill -15 `cat /usr/local/ngin x/logs/nginx.pid` sudo nginx

Now “http://localhost” shows the default Rails page as shown below:

“http://localhost/runlogs” now serves the page from the deployed Rails application.

Now lets configure logging so that the upstream server IP address and port are printed in the log files. In “nginx.conf”, uncomment “log_format” directive and add “$upstream_addr” variable as shown:

Also change the log format to “main” by uncommenting “access_log logs/access.log main;” line as shown above (default format is “combined”). Accessing “http://localhost/runlogs” shows the following lines in “logs/access.log”:

The browser makes multiple requests (3 in this case) to load resources on a page and they are nicely load-balanced on the cluster. If an instance running on port 3002 is killed, then the access log show the entries like:

The second log line shows that server running on port 3002 did not respond and so it automatically fall back to 3000, this is nice!

But this is inefficient because a back-end trip is made even for serving a static file (“/favicon.ico” and “/stylesheets/scaffold.css?1240977992″). This can be easily solved by enabling Rails page caching as described here and here.

More options about logging are described in NginxHttpLogModule and upstream module variables are defined in NginxHttpUpstreamModule.

Here are some nginx resources:

• nginx Website
• nginx Forum (very useful)
• nginx Wiki
• IRC #nginx

Are you using nginx to front-end your GlassFish cluster ?

Apache + JRuby + Rails + GlassFish = Easy Deployment! shows similar steps if you want to front-end your Rails application running using JRuby/GlassFish with Apache.

Hear all about it in Develop with Pleasure, Deploy with Fun: GlassFish and NetBeans for a Better Rails Experience session at Rails Conf next week.

Please leave suggestions on other TOTD (Tip Of The Day) that you’d like to see. A complete archive of all tips is available here.

Technorati: rubyonrails glassfish v3 gem jruby nginx loadbalancing clustering

TOTD #79 showed how to run a trivial Sinatra application using GlassFish Gem. Sinatra provides support for Haml, Erb, Builder, Sass, and Inline templates as described here. This TOTD will show how to get started with creating a Sinatra CRUD application using Haml templates.

Haml is based on one primary principle – Markup should be beautiful because beauty makes you faster. Get started by installing the Haml gem as: /tools/jruby-1.2.0 >./bin/jruby -S gem install haml –no-ri –no-rdoc JRuby limited openssl loaded. gem install jruby-openssl for full support. http://wiki.jruby.org/wiki/JRuby_Builtin_OpenSSL Successfully installed haml-2.0.9 1 gem installed And follow the tutorial, documentation, and reference page for more details.

Sinatra is ORM-agnostic and so any Ruby ORM framework such as ActiveRecord, DataMapper, Sequel, and others. DataMapper with JRuby requires work so this TOTD will show how to use ActiveRecord instead. There is sinatras-hat which allows to create RESTy CRUD apps with Sinatra. There probably are mutiple other ways to create this application but I prefer to understanding the wiring so this blog will use a bare minimal structure.

Anyway, lets get started!

1. Create the database as:

   ~/tools/jruby/samples/sinatra-sample >mysql –user root Welcome to the MySQL monitor.  Commands end with ; or \g. Your MySQL connection id is 664 Server version: 5.1.30 MySQL Community Server (GPL) Type ‘help;’ or ‘\h’ for help. Type ‘\c’ to clear the buffer. mysql> create database hello_development; Query OK, 1 row affected (0.00 sec) mysql> use hello_development; Database changed mysql> CREATE TABLE `runners` (`id` int(11) DEFAULT NULL auto_increment PRIMARY KEY, `distance` float, `minutes` int(11), `created_at` datetime, `updated_at` datetime);              Query OK, 0 rows affected (0.06 sec)

2. Update “hello.rb” from TOTD #79 such that it looks like:
   

   require ‘rubygems’ require ‘sinatra’ require ‘activerecord’ ## Setup ActiveRecord::Base.establish_connection(   :adapter  => “jdbcmysql”,   :host     => “localhost”,   :username => “root”,   :password => “”,   :database => “hello_development” ) ## Models class Runner < ActiveRecord::Base end ## Controller Actions get ‘/hi’ do   “Hello World!” end get ‘/’ do   @runner = Runner.find(:all)   haml :index end get ‘/new’ do   haml :new end get ‘/:id’ do   @runner = Runner.find(params[:id])   if (@runner)     haml :show   else     redirect ‘/’   end end post ‘/’ do   @runner = Runner.new(:distance => params[:distance], :minutes => params[:minutes])   if @runner.save     redirect “/#{@runner.id}”   else     redirect ‘/’   end end

   Firstly, it pulls in the ActiveRecord dependency. Then “ActiveRecord::Base.establish_connection” is used to establish a connection with the previously created database. “Runner” is tagged as a model class by inheriting from “ActiveRecord::Base” and uses the default table name (“runners” in this case). Add four new methods:

   1. Three GET methods to show all the runners, a form to enter new data, and show a particular log entry. Each method requires a HAML template (will be created in next step) to render the information.
   2. One POST method to save the newly created log entry in the database.
3. Create a new directory “views” and create the following files in that directory. Each file serves as a view and rendered from an action in “hello.rb”.
   1. “index.haml”: Show all the runners

      %h1 Listing all runners … %table   %tr     %th Distance     %th Minutes   – @runner.each do |r|     %tr       %td= r.distance       %td= r.minutes %br %a{:href=>”/new”}   New Runner

   2. “new.haml”: Enter a new entry
      

      %h1 Adding a new runner log … %form{:method=>”post”, :action=>”/”}   Distance:   %input{:type=>”text”, :name=>”distance”}   %br   Minutes:   %input{:type=>”text”, :name=>”minutes”}   %br   %input{:type=>”submit”, :value=>”Submit”}   %br

   3. “show.haml”: Show a particular log entry
      

      %h1 Showing a runner log … Dis tance: = @runner.distance %br Minutes: = @runner.minutes %br %br %a{:href=>”/”}= “Show All!”

      The complete directory structure looks like:

      . ./hello.rb ./views ./views/index.haml ./views/new.haml ./views/show.haml

That’s it, now run the application as:

The main page is available at “http://localhost:3000/” and looks like:

Clicking on “New Runner” gives …

Enter the data, and click on “Submit” to show …

Click on “Show All!” to see all the entries added so far …

And after adding few entries the main page looks like …

This application shows Create and Read from the CRUD, it’s fairly easy to add Update and Delete functionality as well but that’s an excercise left for the readers

You’ll hear all about it at Develop with Pleasure, Deploy with Fun: GlassFish and NetBeans for a Better Rails Experience at Rails Conf next week.

Technorati: totd glassfish jruby sinatra crud

Sinatra is a DSL for quickly creating web-applications in Ruby with minimal effort. Like Rails and Merb, Sinatra is not an MVC framework and basically follows a flat-file structure instead. The framework define conventions such as location of static files and views, bootstrap, dev/production/test environment variables, filters, helpers, TDD, and much more.  Read Getting Started for complete details. Even though Sinatra is not a MVC framework but sinatra-gen may be used to generate new Sinatra projects. GlassFish Gem can easily run Rails, Merb, Sinatra, and any other Ruby framework applications based upon Rack. TOTD #70 shows how to run Rails applications and TOTD #53 shows to run Merb applications. This TOTD will explain how to run a trivial Sinatra application. A later blog will describe how to plug a generic Rack-based framework.

Lets see how to get started with Sinatra using JRuby and GlassFish gem.

1. Install Sinatra gem as:

   ~/tools/jruby >./bin/jruby -S gem install sinatra JRuby limited openssl loaded. gem install jruby-openssl for full support. http://wiki.jruby.org/wiki/JRuby_Builtin_OpenSSL Successfully installed sinatra-0.9.1.1 1 gem installed Installing ri documentation for sinatra-0.9.1.1… Installing RDoc documentation for sinatra-0.9.1.1…

2. Create a directory “sinatra-sample”, create a file “hello.rb” in that directory with the contents shown below:
   

   require ‘rubygems’ require ‘sinatra’ get ‘/hi’ do   “Hello World!” end

3. Run your sample using GlassFish gem as:
   

   ~/tools/jruby/samples/sinatra-sample >../../bin/jruby -S glassfish Log file /Users/arungupta/tools/jruby-1.2.0/samples/sinatra-sample/log/development.log does not exist. Creating a new one… Starting GlassFish server at: 192.168.1.145:3000 in development environment… Writing log messages to: /Users/arungupta/tools/jruby-1.2.0/samples/sinatra-sample/log/development.log. Press Ctrl+C to stop.

   And then the output is available at “http://localhost:3000/hi” and looks like:

   

Neat and simple!

You’ll hear all about it at Develop with Pleasure, Deploy with Fun: GlassFish and NetBeans for a Better Rails Experience at Rails Conf next week.

Here is the order in which I’ll seek any help:

• Project Website
• IRC #sinatra
• Twitter
• Mailing List

The next blog will show how to create a Sinatra CRUD application and run it using GlassFish.

Please leave suggestions on other TOTD (Tip Of The Day) that you’d like to see. A complete archive of all the tips is available here.
Technorati: totd glassfish jruby sinatra

SeaChange Affinity uses Rails and GlassFish as their deployment platform. One of their core developers posted tips based upon their experience so far and they are available at:

Rails on GlassFish v2 using Windows

Here are some of the quotes:

Glassfish can really handle a heavy load

and

handling 400 simultaneous users under a supremely heavy load, the memory was holding great

All previous links in this series are archived at LOTD.

Technorati: lotd glassfish jruby rubyonrails windows