Deploying a Ruby app on an AWS production server
with Passenger in Apache mode from RubyGems (without RVM)

This page describes the deployment of a Ruby app, assuming that Passenger was installed through the following operating system configuration or installation method: generic installation through RubyGems (without RVM). Is this not how Passenger was installed? Go back to the operating system / installation method selection menu.

On this page you will learn how you can deploy your app to a server that is running Passenger. You can either follow these instructions with your own app, or you can use the sample Rails app we prepared.

Please tell us a bit about your app and your system

With this information, we can provide you with the most relevant instructions.


Table of contents

1 Transferring the app code to the server

1.1 Push your code to a Git repository

If you are using our sample app, you can skip to the next step.

We want to transfer our application's code to the server. The easiest way to do that is via Git.

If you have already setup a Git repository, push your application's code to that repository by running this on your local computer:

Copy
$ git push

If you have not already setup a Git repository, go to Github, create a repository and push your application's code there.

1.2 Login to your server, create a user for the app

Login to your server with SSH:

Copy
$ ssh -i your_ec2_key.pem adminuser@yourserver.com

Replace adminuser with the name of an account with administrator privileges or sudo privileges. This is usually admin, ec2-user, root or ubuntu.

Starting from this point, unless stated otherwise, all commands that we instruct you to run should be run on the server, not on your local computer!

Now that you have logged in, you should create an operating system user account for your app. For security reasons, it is a good idea to run each app under its own user account, in order to limit the damage that security vulnerabilities in the app can do. Passenger will automatically run your app under this user account as part of its user account sandboxing feature.

You should give the user account the same name as your app. But for demonstration purposes, this tutorial names the user account myappuser.

Copy
$ sudo adduser myappuser

We also ensure that that user has your SSH key installed:

Copy
$ sudo mkdir -p ~myappuser/.ssh $ touch $HOME/.ssh/authorized_keys $ sudo sh -c "cat $HOME/.ssh/authorized_keys >> ~myappuser/.ssh/authorized_keys" $ sudo chown -R myappuser: ~myappuser/.ssh $ sudo chmod 700 ~myappuser/.ssh $ sudo sh -c "chmod 600 ~myappuser/.ssh/*"

1.3 Install Git on the server

Please install Git from git-scm.com.

1.4 Pull code

You need to pick a location in which to permanently store your application's code. A good location is /var/www/APP_NAME. Let us create that directory.

Copy
$ sudo mkdir -p /var/www/myapp $ sudo chown myappuser: /var/www/myapp

Replace myapp and myappuser with your app's name and your app user account's name.

Now let us pull the code from Git:

Copy
$ cd /var/www/myapp $ sudo -u myappuser -H git clone git://github.com/username/myapp.git code

If you are using our sample app, use this Git clone command instead:

Copy
$ cd /var/www/myapp $ sudo -u myappuser -H git clone --branch=end_result https://github.com/phusion/passenger-ruby-rails-demo.git code

Your app's code now lives on the server at /var/www/myapp/code.

2 Preparing the app's environment

2.1 Login as the app's user

All subsequent instructions must be run under the application's user account. While logged into your server, login under the application's user account as follows:

Copy
$ sudo -u myappuser -H bash -l

Since you are using RVM, make sure that you activate the Ruby version that you want to run your app under. For example:

Copy
$ rvm use ruby-2.3.3

2.2 Install app dependencies

Your application has various dependencies. They must be installed. Most of these dependencies are gems in your Gemfile, managed by Bundler. You can install them by running bundle install --deployment --without development test -j 2 in your app's directory:

Copy
$ cd /var/www/myapp/code $ bundle install --deployment --without development test

Your app may also depend on services, such as PostgreSQL, Redis, etc. Installing services that your app depends on is outside of this tutorial's scope.

2.3 Configure database.yml and secrets.yml

Since your Rails app probably needs a database, you need to edit config/database.yml. For demonstration purposes, we will setup your app with an SQLite database because that is the easiest.

Open the file:

Copy
$ nano config/database.yml

Ensure that the production section looks like this:

Copy
production: adapter: sqlite3 database: db/production.sqlite3

Rails also needs a unique secret key with which to encrypt its sessions. Starting from Rails 4, this secret key is stored in config/secrets.yml. But first, we need to generate a secret key. Run:

Copy
$ bundle exec rake secret ...

This command will output a secret key. Copy that value to your clipboard. Next, open config/secrets.yml:

Copy
$ nano config/secrets.yml

If the file already exists, look for this:

Copy
production: secret_key_base: <%=ENV["SECRET_KEY_BASE"]%>

Then replace it with the following. If the file didn't already exist, simply insert the following.

Copy
production: secret_key_base: the value that you copied from 'rake secret'

To prevent other users on the system from reading sensitive information belonging to your app, let's tighten the security on the configuration directory and the database directory:

Copy
$ chmod 700 config db $ chmod 600 config/database.yml config/secrets.yml

2.4 Compile Rails assets and run database migrations

Run the following command to compile assets for the Rails asset pipeline, and to run database migrations:

Copy
$ bundle exec rake assets:precompile db:migrate RAILS_ENV=production

3 Configuring Apache and Passenger

Now that you are done with transferring your app's code to the server and setting up an environment for your app, it is time to configure Apache so that Passenger knows how to serve your app.

3.1 Determine the Ruby command that Passenger should use

We need to tell Passenger which Ruby command it should use to run your app, just in case there are multiple Ruby interpreters on your system. Please run passenger-config about ruby-command to find out which Ruby interpreter you are using. For example:

Copy
$ passenger-config about ruby-command passenger-config was invoked through the following Ruby interpreter: Command: /usr/local/rvm/gems/ruby-2.3.3/wrappers/ruby Version: ruby 2.3.3p85 (2015-02-26 revision 49769) [x86_64-linux] ...

Please take note of the path after "Command" (in this example, /usr/local/rvm/gems/ruby-2.3.3/wrappers/ruby). You will need it in one of the next steps.

3.2 Go back to the admin account

You have previously logged into your app's user account in order to prepare the app's environment. That user does not have sudo access. In the next steps, you need to edit configuration files, for which sudo access is needed. So you need to switch back to the admin account.

This can be done by simply exiting the shell that was logged into the app's user account. You will then be dropped back to the admin account. For example:

Copy
# This is what you previously ran: admin$ sudo -u myappuser -H bash -l myappuser$ ... # Type `exit` to go back to the account you were before myappuser$ exit admin$ _

3.3 Edit Apache configuration file

We need to edit your Apache configuration file and setup a virtual host entry that points to your app. This virtual host entry tells Apache (and Passenger) where your app is located.

Open your Apache configuration file. For example:

Copy
$ sudo nano /etc/apache2/apache2.conf

Don't know where your Apache configuration file is? Read Working with the Apache configuration file.

Let us add a virtual host entry at the end of that file. At the end of the file, insert:

Copy
<VirtualHost *:80> ServerName yourserver.com # Tell Apache and Passenger where your app's 'public' directory is DocumentRoot /var/www/myapp/code/public PassengerRuby /path-to-ruby # Relax Apache security settings <Directory /var/www/myapp/code/public> Allow from all Options -MultiViews # Uncomment this if you're on Apache >= 2.4: #Require all granted </Directory> </VirtualHost>

Replace yourserver.com with your server's host name, and replace /var/www/myapp/code with your application's code directory path. However, make sure that Apache is configured to point to the public subdirectory inside it!

Replace /path-to-ruby with the Ruby command that you obtained in step 3.1.

When you are done, restart Apache:

Copy
$ sudo apachectl restart

(Depending on your operating system, the right command may be apache2ctl instead of apachectl.)

3.4 Test drive

You should now be able to access your app through the server's host name! Try running this from your local computer. Replace yourserver.com with your server's hostname, exactly as it appears in the Apache config file's ServerName directive.

Copy
$ curl http://yourserver.com/ ...your app's front page HTML...

If you do not see your app's front page HTML, then these are the most likely causes:

  1. You did not correctly configure your ServerName directive. The ServerName must exactly match the host name in the URL. For example, if you use the command curl http://45.55.91.235/ to access your app, then the ServerName must be 45.55.91.235.
  2. You did not setup DNS records. Setting up DNS is outside the scope of this tutorial. In the mean time, we recommend that you use your server's IP address as the server name.

Next step

Congratulations, you have successfully deployed your app!

Continue: Deploying updates »