{"id":160,"date":"2008-03-27T10:46:00","date_gmt":"2008-03-27T18:46:00","guid":{"rendered":"http:\/\/onehub.com\/blog\/posts\/setting-up-a-rails-stack-with-nginx-and-clustered-mongrels-2"},"modified":"2008-03-27T10:46:00","modified_gmt":"2008-03-27T18:46:00","slug":"setting-up-a-rails-stack-with-nginx-and-clustered-mongrels-2","status":"publish","type":"post","link":"https:\/\/www.onehub.com\/blog\/2008\/03\/27\/setting-up-a-rails-stack-with-nginx-and-clustered-mongrels-2\/","title":{"rendered":"Setting up a rails stack with nginx and clustered mongrels"},"content":{"rendered":"

Linux, MySQL<\/a>, nginx<\/a>, Mongrel<\/a> , Rails<\/a>, and friends.<\/strong><\/p>\n

Big Picture:<\/h4>\n

An ideal setup uses two different servers or virtual machines to split up the load and facilitate scaling. The first machine runs nginx serving static content and acting as a reverse proxy passing dynamic requests to a pool of mongrels running the rails application. The second machine is a dedicated MySQL database server. Even if you only have one physical box, two virtual machines (Xen based) is preferred, it is easier to scale and doesn\u2019t require as much memory context switching. The hosting provider we picked to run our service, Engine Yard, uses a similar setup based on Gentoo and Xen.<\/p>\n

Linux Setup:<\/h4>\n

All of the tools and applications used in this stack are actively developed and available in most package management systems. This document will assume you use Debian\/GNU Linux, but will work equally well on Ubuntu. If choose to use Fedora, Gentoo or another distribution, you will need substitute commands for your package-management tool.<\/p>\n

Installing and configuring Linux is outside the scope of this document, but you should strive for a minimalist system based on a recent release of the 2.6 kernel. Debian and Ubuntu both offer a number of \u201cpre-made\u201d configurations in their installers, just avoid installing anything more than the base system as it will just add more software that you will have to disable or remove later.<\/p>\n

Conventions:<\/h4>\n

$<\/code> indicates a standard shell prompt.<\/p>\n

#<\/code> indicates the command needs to be run as the root user, either by switching to the root user account or assuming root privileges with a tool like sudo<\/code>.<\/p>\n

Tools:<\/h4>\n

While installing and managing a Linux server, you will often need the power of the root account. However, because the root user is so powerful, it dangerous to use all the time. A better solution is to use a standard user account and only assume the privileges of the root user when necessary. Sudo was designed to do exactly this.<\/p>\n

# apt-get install sudo<\/code><\/p>\n

Once the package is installed, the list of users able to assume root powers is controlled by \/etc\/sudoers<\/code>. This file must be edited with the visudo<\/code> command, which will open your default editor (or vi if your shell does not have an editor set).<\/p>\n

# visudo<\/code><\/p>\n

If you are unfamiliar with vi, press \u2018i\u2019 to put it in insert mode, then add a line to enable your user.<\/p>\n

username ALL=(ALL) ALL<\/code><\/p>\n

You can read more on the sudo package to better understand this configuration file. Once you have completed your edit, press escape (ESC) to exit editor mode. To save the file type \u2019:\u2019 to enter command mode and then type \u2018w\u2019 and \u2018q\u2019 (meaning write and quit). The file should be properly saved and your user will now be able to assume root privileges.<\/p>\n

Database Server:<\/h4>\n

MySQL is our database of choice, it is popular in the Rails community, proven to scale, and fast (especially in a read heavy environment).<\/p>\n

To install, use the mysql-server package.<\/p>\n

# apt-get install mysql-server<\/code><\/p>\n

Your package manager should handle all the dependencies, including the mysql-client package, which we will use to improve our Ruby to MySQL performance. The installer may prompt you for a few questions, aim to accept the defaults and enter in information specific to your server.<\/p>\n

Database Configuration:<\/h4>\n

The configuration file for MySQL is usually located in \/etc\/mysql as my.cnf<\/code>. Most MySQL packages also include a number of other simple configurations to help MySQL perform better. Take a look at my-large.cnf<\/code> and my-small.cnf<\/code> in \/usr\/share\/mysql<\/code> and update your \/etc\/mysql\/my.cnf<\/code> to reflect your hardware or virtual machine\u2019s configuration. MySQL tuning is a complex subject, but some basic configuration can go a long way to helping the application to perform well.<\/p>\n

Before adding any databases, it is also important to instruct MySQL to use more international character encodings and collations. Storing the data in this way will make internationalization a simpler task in the future.<\/p>\n

In \/etc\/mysql\/my.cnf<\/code>:<\/p>\n

[client]\ndefault-character-set = utf8[server]\ndefault-character-set = utf8\ndefault-collation = utf8_general_ci<\/code><\/pre>\n
These directives instruct MySQL to use UTF<\/span>-8 for everything. If you have not already, restart your database server.<\/p>\n
# \/etc\/init.d\/mysql restart<\/code><\/p>\n
You can now add the database to the server.<\/p>\n
$ mysqladmin -u root create database_name<\/code><\/p>\n
Consult the MySQL documentation to change the root user\u2019s password and to add a user with privileges on the specific database. It may be simpler to use a MySQL administration GUI<\/span> to achieve these tasks.<\/p>\n
Application Server<\/h4>\n
The application server requires the most complex setup.<\/p>\n
Ruby & Ruby Gems<\/h5>\n
To start, you will need Ruby<\/a> and Ruby Gems<\/a>.<\/p>\n
# apt-get install ruby rubygems<\/code><\/p>\n
ruby<\/code> is a transitional package, currently it will install Ruby 1.8.6 (as of March 20, 2008), unless you know of a specific feature or bug to avoid, it is simplest to let the the package-management system handle which version you get. Ruby Gems<\/a> is a package management system for system for third party ruby libraries, it functions much like CPAN<\/span><\/a> for Perl<\/a> or PEAR<\/span><\/a> for PHP<\/span><\/a>. We\u2019re going to want a number of gems, but first lets update gems itself, from within itself\u2014how meta.<\/p>\n
# gem update \u2014system<\/code><\/p>\n
Ruby gems should now download and recompile itself. Once that has completed, you can install the gems we\u2019ll need. The first one is a bit trickier than the others.<\/p>\n
# gem install mysql<\/code><\/p>\n
The mysql<\/code> gem provides fast C bindings between Ruby and MySQL, if you aren\u2019t already using these on your local machine you should give them a spin, the performance increase is well worth the minimal amount of effort required to install them. If you have your MySQL installed in a non-standard location, you may have to pass in mysql_config<\/code>.<\/p>\n
# gem install mysql \u2013\u2013 \u2013\u2013with-mysql-config=\/your\/path\/to\/mysql_config<\/code><\/p>\n
With mysql<\/code> all setup and out of the way, its easy to install everything else you need.<\/p>\n
# gem install rails mongrel mongrel_cluster<\/code><\/p>\n
rails<\/code> is optional, you may choose to freeze rails inside your application, which would override this gem. mongrel<\/code> and mongrel_cluster<\/code> are the gems that provide us with our application server. Before diving into mongrel, there are a few more gems you may want that are entirely optional.<\/p>\n
# gem install tmail swiftiply<\/code><\/p>\n
tmail<\/code> is an e-mail library, and is the same library that the ActiveMailer<\/code> component of Rails uses. Rails 2.0 now looks for this gem before loading its own bundled copy; by installing the gem you can get extra features and bug fixes that may have been released.<\/p>\n
swiftiply<\/code> is a gem that patches mongrel to use the event based network programming model, commonly called \u201cevented mongrels\u201d. You can find more on Ezra Zygmuntowicz\u2019s Brainspl.at<\/a> and my journal<\/a> where I did some elementary benchmarking<\/a>.<\/p>\n
Mongrel<\/h4>\n
Mongrel<\/a> will serve as our application server, containing an instance of the Ruby interpreter and our Rails application.<\/p>\n
Mongrel is a fast HTTP<\/span> library and server for Ruby that is intended for hosting Ruby web applications of any kind using plain HTTP<\/span> rather than FastCGI or SCGI<\/span>.<\/p><\/blockquote>\n
From inside your rails application you can start a mongrel server and interact with your application. By default, rails will start in development mode.<\/p>\n
$ mongrel_rails start<\/code><\/p>\n
A daemon with the application should now be running on port 3000. ctrl+c<\/code> to stop the server, lets move on to mongrel_cluster<\/p>\n
Mongrel Cluster<\/h4>\n
Mongrel Cluster will manage a pool of mongrels that nginx will reverse proxy requests to.<\/p>\n
Mongrel_cluster is a GemPlugin that wrappers the mongrel HTTP<\/span> server and simplifies the deployment of webapps using a cluster of mongrel servers. Mongrel_cluster will conveniently configure and control several mongrel servers, or groups of mongrel servers, which are then load balanced using a reverse proxy solution.<\/p><\/blockquote>\n
The wiki<\/a> has more extensive documentation, right now we will only look at the basics.<\/p>\n
# mongrel_rails cluster::configure -e production -p 8000 -N 3 -c \/path\/to\/your\/application -a 127.0.0.1 \u2014user mongrel \u2014group mongrel<\/code><\/p>\n
This line creates the file application\/path\/config\/mongrel_cluster.yml<\/code>. Most of the switches are self explanatory, -a 127.0.0.1<\/code> configures the IP that the server binds to, by making it local you make it impossible to hit a mongrel directly without passing through the proxy. -p<\/code> and -N<\/code> configure the start port and the number of mongrels to start, so 8000, 8001, and 8002 in this case. \u2014user<\/code> and \u2014group<\/code> are the system user and group the servers will run under; because the mongrels run on an unprivileged port, they may run as an unprivileged user to improve security. -e<\/code> is the environment our rails application will run in and -c<\/code> is the path to our application (mongrel cluster will look for its configuration file at this path + config\/mongrel_cluster.yml<\/code>, you may use -C<\/code> if you want to directly specify a YAML<\/span> config file).<\/p>\n
\u2014-\nuser: mongrel\ngroup: mongrel\ncwd: \/path\/to\/my\/application\naddress: 127.0.0.1\nport: \"8000\"\nservers: 3\nenvironment: production\npid_file: log\/mongrel.pid\n<\/code><\/pre>\n
Evented Mongrel<\/h4>\n
To use evented mongrels, you just need to pass an environmental variable EVENT=1<\/code> while starting your server. With mongrel_cluster<\/code> that will look like this:<\/p>\n
# EVENT=1 mongrel_rails cluster::start<\/code><\/p>\n
Don\u2019t forget to pass it even if you are just restarting the servers! At the top of the mongrel.log you should see it notify you that it is using events.<\/p>\n
Web Server<\/h4>\n
Currently our application server and web server are on the same virtual machine. In the future, we may choose to scale by moving the web server and static content to another virtual machine (or perhaps a CDN<\/span> like Akamai) and have pure application servers. For now, we will keep things simple.<\/p>\n
nginx<\/h4>\n
nginx<\/a> is a very fast proxy that we will also use to serve our static content.<\/p>\n
# apt-get install nginx<\/code><\/p>\n
Configuration is very straight forward, everything is done in \/etc\/nginx\/nginx.conf<\/code>. The following configuration is based on \u201cEzra Zygmuntowicz\u2019s Brainspl.at\u201d nginx.conf<\/a>.<\/p>\n
# user and group to run as\nuser  www-data www-data;# number of nginx workers\nworker_processes  6;# pid of nginx master process\npid \/var\/run\/nginx.pid;# Number of worker connections. 1024 is a good default\nevents {\n  worker_connections 1024;\n}# start the http module where we config http access.\nhttp {\n  # pull in mime-types. You can break out your config\n  # into as many include's as you want to make it cleaner\n  include \/etc\/nginx\/mime.types;  # set a default type for the rare situation that\n  # nothing matches from the mimie-type include\n  default_type  application\/octet-stream;  # configure log format\n  log_format main '$remote_addr - $remote_user [$time_local] '\n                  '\"$request\" $status  $body_bytes_sent \"$http_referer\" '\n                  '\"$http_user_agent\" \"$http_x_forwarded_for\"';  # main access log\n  access_log  \/var\/log\/nginx_access.log  main;  # main error log\n  error_log  \/var\/log\/nginx_error.log debug;  # no sendfile on OSX\n  sendfile on;  # These are good default values.\n  tcp_nopush        on;\n  tcp_nodelay       off;\n  # output compression saves bandwidth\n  gzip            on;\n  gzip_http_version 1.0;\n  gzip_comp_level 2;\n  gzip_proxied any;\n  gzip_types      text\/plain text\/html text\/css application\/x-javascript text\/xml application\/xml application\/xml+rss text\/javascript;  # this is where you define your mongrel clusters.\n  # you need one of these blocks for each cluster\n  # and each one needs its own name to refer to it later.\n  upstream mongrel {\n        fair; # This changes from round-robin based to load based.\n    server 127.0.0.1:8000;\n    server 127.0.0.1:8001;\n    server 127.0.0.1:8002;\n  }  # the server directive is nginx's virtual host directive.\n  server {\n    # port to listen on. Can also be set to an IP:PORT\n    listen 80;    # Set the max size for file uploads to 50Mb\n    client_max_body_size 50M;    # sets the domain[s] that this vhost server requests for\n    # server_name www.[yourdomain].com [yourdomain].com;    # doc root\n    root \/path\/to\/your\/application\/public;    # vhost specific access log\n    access_log  \/var\/log\/nginx.vhost.access.log  main;    # this rewrites all the requests to the maintenance.html\n    # page if it exists in the doc root. This is for capistrano's\n    # disable web task\n    if (-f $document_root\/system\/maintenance.html) {\n      rewrite  ^(.*)$  \/system\/maintenance.html last;\n      break;\n    }    location \/ {\n      # needed to forward user's IP address to rails\n      proxy_set_header  X-Real-IP  $remote_addr;      # needed for HTTPS\n      proxy_set_header  X-Forwarded-For $proxy_add_x_forwarded_for;\n      proxy_set_header Host $http_host;\n      proxy_redirect false;\n      proxy_max_temp_file_size 0;      # If the file exists as a static file serve it directly without\n      # running all the other rewite tests on it\n      if (-f $request_filename) {\n        break;\n      }      # check for index.html for directory index\n      # if its there on the filesystem then rewite\n      # the url to add \/index.html to the end of it\n      # and then break to send it to the next config rules.\n      if (-f $request_filename\/index.html) {\n        rewrite (.*) $1\/index.html break;\n      }      # this is the meat of the rails page caching config\n      # it adds .html to the end of the url and then checks\n      # the filesystem for that file. If it exists, then we\n      # rewite the url to have explicit .html on the end\n      # and then send it on its way to the next config rule.\n      # if there is no file on the fs then it sets all the\n      # necessary headers and proxies to our upstream mongrels\n      if (-f $request_filename.html) {\n        rewrite (.*) $1.html break;\n      }      if (!-f $request_filename) {\n        proxy_pass http:\/\/mongrel;\n        break;\n      }\n    }    error_page   500 502 503 504  \/500.html;\n    location = \/500.html {\n      root   \/path\/to\/your\/application\/public;\n    }\n  }\n}<\/code><\/pre>\n
Now that you have nginx configured, start it and you should have a solid rails stack up and running.<\/p>\n
# \/etc\/init.d\/nginx start<\/code><\/p>\n
Request Cycle<\/h4>\n
Unlike more traditional setups, each individual request does not necessarily take the same path. Nginx monitors port 80 and accepts all incoming requests. Using the rewrite rules it looks for a file in the public<\/code> directory with \/url\/path + .html<\/code>. If it finds this static HTML<\/span> page, it replies. It also searches for index.html<\/code> to retrieve folder indexes. These static HTML<\/span> files are generated by rails\u2019 page caching mechanism, and provide enormous performance gains at a cost of flexibility. If nginx is unable to find an HTML<\/span> page, it forwards the request to the cluster of mongrels. The mongrel that gets the request depends on which proxy algorithm you choose; the fair option spread the requests based on availability. Once received, the mongrel then runs the request through the rails application: the database is hit, ruby does some magic, and a page is completed and passed back to the mongrel which logs the request as complete and passes it back to nginx. If page caching is enabled, rails writes the page that was just generated to the public<\/code> directory (lazy caching) before handing it off to the mongrel. Nginx takes this page and forwards it to the browser, acting as a proxy (gateway). The general process is repeated on each request, but the mongrel that is given the dynamic request will be different, and a cached page may be found, avoiding the need to engage the mongrels all together.<\/p>\n","protected":false},"excerpt":{"rendered":"
Linux, MySQL, nginx, Mongrel , Rails, and friends. Big Picture: An ideal setup uses two different servers or virtual machines to split up the load and facilitate scaling. The first machine runs nginx serving static content and acting as a […]<\/p>\n","protected":false},"author":7,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_themeisle_gutenberg_block_has_review":false},"categories":[1],"tags":[],"_links":{"self":[{"href":"https:\/\/www.onehub.com\/blog\/wp-json\/wp\/v2\/posts\/160"}],"collection":[{"href":"https:\/\/www.onehub.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.onehub.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.onehub.com\/blog\/wp-json\/wp\/v2\/users\/7"}],"replies":[{"embeddable":true,"href":"https:\/\/www.onehub.com\/blog\/wp-json\/wp\/v2\/comments?post=160"}],"version-history":[{"count":0,"href":"https:\/\/www.onehub.com\/blog\/wp-json\/wp\/v2\/posts\/160\/revisions"}],"wp:attachment":[{"href":"https:\/\/www.onehub.com\/blog\/wp-json\/wp\/v2\/media?parent=160"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.onehub.com\/blog\/wp-json\/wp\/v2\/categories?post=160"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.onehub.com\/blog\/wp-json\/wp\/v2\/tags?post=160"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}