what is 'your_port_num'  how do I set that?


Can any one public a video tuts with how to deploy rails app , just tried over and over its sucks !!! 
i want to deploy rails up easy and fast not annoying with copy-past text !!! 
i even don't see that this tutorial is that useful cuz its just doesn't work !!! 

Hello! I have done the entire tutorial, the last message on terminal is:

bash: line 1: 30225 Aborted                 ( RAILS_ENV=production /usr/local/rvm/bin/rvm default do bundle exec rake assets:precompile )
rake stderr: Nothing written

On the app directory doesn't have the "current" dir, can you help me with this? 

Hi, after I run the  'cap production deploy:initial' command, the console ask me for the passphrase for my public key, I enter that but after that nothing happens, can anyone help me ?

My ruby set up is with rbenv but this example is with rvm. I am currently getting this error when I run  cap production deploy:initial: 

cap aborted!
SSHKit::Runner::ExecuteError: Exception while executing on host : rvm exit status: 127
rvm stdout: bash: /home/user/.rvm/bin/rvm: No such file or directory
rvm stderr: Nothing written

There is rbenv instead of rvm on my server. Is the setting basically the same with no modifications if I am using rbenv?

Please advice. Thanks.


Nice tutorial !

There something I miss : is puma installed as a daemon with Upstart Script ? 

where are you binding puma ???
In deploy.rb 

```
set :puma_bind,       "unix://#{shared_path}/tmp/sockets/#{fetch(:application)}-puma.sock"
set :puma_state,      "#{shared_path}/tmp/pids/puma.state"
set :puma_pid,        "#{shared_path}/tmp/pids/puma.pid"
```

but its not generating puma.pid or #{fetch(:application)}-puma.sock files also my PUMA is not running although i got this in my log

```
DEBUG [4151b0ca] 	Puma starting in single mode...
DEBUG [4151b0ca] 	
DEBUG [4151b0ca] 	* Version 2.13.4 (ruby 2.2.1-p85), codename: A Midsummer Code's Dream
DEBUG [4151b0ca] 	
DEBUG [4151b0ca] 	* Min threads: 4, max threads: 16
DEBUG [4151b0ca] 	
DEBUG [4151b0ca] 	* Environment: production
DEBUG [4151b0ca] 	
DEBUG [4151b0ca] 	* Daemonizing...

```
after scratching here and there i found puma log and it is
**puma.access.log
**

```
=== puma startup: 2015-09-09 15:22:22 -0400 ===
/home/deploy/apps/golf/releases/20150909192056/app/api/v1/api.rb:5:in `format': no implicit conversion of Symbol into String (TypeError)
	from /home/deploy/apps/golf/releases/20150909192056/app/api/v1/api.rb:5:in `<class:API>'
	from /home/deploy/apps/golf/releases/20150909192056/app/api/v1/api.rb:4:in `<module:V1>'
	from /home/deploy/apps/golf/releases/20150909192056/app/api/v1/api.rb:3:in `<top (required)>'
	from /home/deploy/apps/golf/shared/bundle/ruby/2.2.0/gems/activesupport-4.2.1/lib/active_support/dependencies.rb:274:in `require'
	from /home/deploy/apps/golf/shared/bundle/ruby/2.2.0/gems/activesupport-4.2.1/lib/active_support/dependencies.rb:274:in `block in require'
	from /home/deploy/apps/golf/shared/bundle/ruby/2.2.0/gems/activesupport-4.2.1/lib/active_support/dependencies.rb:240:in `load_dependency'
	from /home/deploy/apps/golf/shared/bundle/ruby/2.2.0/gems/activesupport-4.2.1/lib/active_support/dependencies.rb:274:in `require'
	from /home/deploy/apps/golf/shared/bundle/ruby/2.2.0/gems/activesupport-4.2.1/lib/active_support/dependencies.rb:360:in `require_or_load'
	from /home/deploy/apps/golf/shared/bundle/ruby/2.2.0/gems/activesupport-4.2.1/lib/active_support/dependencies.rb:494:in `load_missing_constant'
	from /home/deploy/apps/golf/shared/bundle/ruby/2.2.0/gems/activesupport-4.2.1/lib/active_support/dependencies.rb:184:in `const_missing'
	from /home/deploy/apps/golf/releases/20150909192056/config/routes.rb:10:in `block in <top (required)>'
	from /home/deploy/apps/golf/shared/bundle/ruby/2.2.0/gems/actionpack-4.2.1/lib/action_dispatch/routing/route_set.rb:432:in `instance_exec'
	from /home/deploy/apps/golf/shared/bundle/ruby/2.2.0/gems/actionpack-4.2.1/lib/action_dispatch/routing/route_set.rb:432:in `eval_block'
	from /home/deploy/apps/golf/shared/bundle/ruby/2.2.0/gems/actionpack-4.2.1/lib/action_dispatch/routing/route_set.rb:410:in `draw'
	from /home/deploy/apps/golf/releases/20150909192056/config/routes.rb:1:in `<top (required)>'
	from /home/deploy/apps/golf/shared/bundle/ruby/2.2.0/gems/activesupport-4.2.1/lib/active_support/dependencies.rb:268:in `load'
	from /home/deploy/apps/golf/shared/bundle/ruby/2.2.0/gems/activesupport-4.2.1/lib/active_support/dependencies.rb:268:in `block in load'
	from /home/deploy/apps/golf/shared/bundle/ruby/2.2.0/gems/activesupport-4.2.1/lib/active_support/dependencies.rb:240:in `load_dependency'
	from /home/deploy/apps/golf/shared/bundle/ruby/2.2.0/gems/activesupport-4.2.1/lib/active_support/dependencies.rb:268:in `load'
	from /home/deploy/apps/golf/shared/bundle/ruby/2.2.0/gems/railties-4.2.1/lib/rails/application/routes_reloader.rb:40:in `block in load_paths'
	from /home/deploy/apps/golf/shared/bundle/ruby/2.2.0/gems/railties-4.2.1/lib/rails/application/routes_reloader.rb:40:in `each'
	from /home/deploy/apps/golf/shared/bundle/ruby/2.2.0/gems/railties-4.2.1/lib/rails/application/routes_reloader.rb:40:in `load_paths'
	from /home/deploy/apps/golf/shared/bundle/ruby/2.2.0/gems/railties-4.2.1/lib/rails/application/routes_reloader.rb:16:in `reload!'
	from /home/deploy/apps/golf/shared/bundle/ruby/2.2.0/gems/railties-4.2.1/lib/rails/application.rb:169:in `reload_routes!'
	from /home/deploy/apps/golf/shared/bundle/ruby/2.2.0/gems/devise-3.5.2/lib/devise/rails.rb:14:in `block in <class:Engine>'
	from /home/deploy/apps/golf/shared/bundle/ruby/2.2.0/gems/activesupport-4.2.1/lib/active_support/lazy_load_hooks.rb:36:in `call'
	from /home/deploy/apps/golf/shared/bundle/ruby/2.2.0/gems/activesupport-4.2.1/lib/active_support/lazy_load_hooks.rb:36:in `execute_hook'
	from /home/deploy/apps/golf/shared/bundle/ruby/2.2.0/gems/activesupport-4.2.1/lib/active_support/lazy_load_hooks.rb:45:in `block in run_load_hooks'
	from /home/deploy/apps/golf/shared/bundle/ruby/2.2.0/gems/activesupport-4.2.1/lib/active_support/lazy_load_hooks.rb:44:in `each'
	from /home/deploy/apps/golf/shared/bundle/ruby/2.2.0/gems/activesupport-4.2.1/lib/active_support/lazy_load_hooks.rb:44:in `run_load_hooks'
	from /home/deploy/apps/golf/shared/bundle/ruby/2.2.0/gems/railties-4.2.1/lib/rails/application/finisher.rb:55:in `block in <module:Finisher>'
	from /home/deploy/apps/golf/shared/bundle/ruby/2.2.0/gems/railties-4.2.1/lib/rails/initializable.rb:30:in `instance_exec'
	from /home/deploy/apps/golf/shared/bundle/ruby/2.2.0/gems/railties-4.2.1/lib/rails/initializable.rb:30:in `run'
	from /home/deploy/apps/golf/shared/bundle/ruby/2.2.0/gems/railties-4.2.1/lib/rails/initializable.rb:55:in `block in run_initializers'
	from /home/deploy/.rvm/rubies/ruby-2.2.1/lib/ruby/2.2.0/tsort.rb:226:in `block in tsort_each'
	from /home/deploy/.rvm/rubies/ruby-2.2.1/lib/ruby/2.2.0/tsort.rb:348:in `block (2 levels) in each_strongly_connected_component'
	from /home/deploy/.rvm/rubies/ruby-2.2.1/lib/ruby/2.2.0/tsort.rb:429:in `each_strongly_connected_component_from'
	from /home/deploy/.rvm/rubies/ruby-2.2.1/lib/ruby/2.2.0/tsort.rb:347:in `block in each_strongly_connected_component'
	from /home/deploy/.rvm/rubies/ruby-2.2.1/lib/ruby/2.2.0/tsort.rb:345:in `each'
	from /home/deploy/.rvm/rubies/ruby-2.2.1/lib/ruby/2.2.0/tsort.rb:345:in `call'
	from /home/deploy/.rvm/rubies/ruby-2.2.1/lib/ruby/2.2.0/tsort.rb:345:in `each_strongly_connected_component'
	from /home/deploy/.rvm/rubies/ruby-2.2.1/lib/ruby/2.2.0/tsort.rb:224:in `tsort_each'
	from /home/deploy/.rvm/rubies/ruby-2.2.1/lib/ruby/2.2.0/tsort.rb:203:in `tsort_each'
	from /home/deploy/apps/golf/shared/bundle/ruby/2.2.0/gems/railties-4.2.1/lib/rails/initializable.rb:54:in `run_initializers'
	from /home/deploy/apps/golf/shared/bundle/ruby/2.2.0/gems/railties-4.2.1/lib/rails/application.rb:352:in `initialize!'
	from /home/deploy/apps/golf/current/config/environment.rb:5:in `<top (required)>'
	from /home/deploy/apps/golf/current/config.ru:3:in `require'
	from /home/deploy/apps/golf/current/config.ru:3:in `block in <main>'
	from /home/deploy/apps/golf/shared/bundle/ruby/2.2.0/gems/puma-2.13.4/lib/puma/rack/builder.rb:184:in `instance_eval'
	from /home/deploy/apps/golf/shared/bundle/ruby/2.2.0/gems/puma-2.13.4/lib/puma/rack/builder.rb:184:in `initialize'
	from /home/deploy/apps/golf/current/config.ru:in `new'
	from /home/deploy/apps/golf/current/config.ru:in `<main>'
	from /home/deploy/apps/golf/shared/bundle/ruby/2.2.0/gems/puma-2.13.4/lib/puma/rack/builder.rb:170:in `eval'
	from /home/deploy/apps/golf/shared/bundle/ruby/2.2.0/gems/puma-2.13.4/lib/puma/rack/builder.rb:170:in `new_from_string'
	from /home/deploy/apps/golf/shared/bundle/ruby/2.2.0/gems/puma-2.13.4/lib/puma/rack/builder.rb:161:in `parse_file'
	from /home/deploy/apps/golf/shared/bundle/ruby/2.2.0/gems/puma-2.13.4/lib/puma/configuration.rb:129:in `load_rackup'
	from /home/deploy/apps/golf/shared/bundle/ruby/2.2.0/gems/puma-2.13.4/lib/puma/configuration.rb:96:in `app'
	from /home/deploy/apps/golf/shared/bundle/ruby/2.2.0/gems/puma-2.13.4/lib/puma/runner.rb:113:in `load_and_bind'
	from /home/deploy/apps/golf/shared/bundle/ruby/2.2.0/gems/puma-2.13.4/lib/puma/single.rb:79:in `run'
	from /home/deploy/apps/golf/shared/bundle/ruby/2.2.0/gems/puma-2.13.4/lib/puma/cli.rb:215:in `run'
	from /home/deploy/apps/golf/shared/bundle/ruby/2.2.0/gems/puma-2.13.4/bin/puma:10:in `<top (required)>'
	from /home/deploy/apps/golf/shared/bundle/ruby/2.2.0/bin/puma:23:in `load'
	from /home/deploy/apps/golf/shared/bundle/ruby/2.2.0/bin/puma:23:in `<main>'

```

here is  log

```
=== puma startup: 2015-09-09 17:01:34 -0400 ===
/home/deploy/apps/golf/releases/20150909205712/app/api/v1/api.rb:5:in `format': no implicit conversion of Symbol into String (TypeError)
	from /home/deploy/apps/golf/releases/20150909205712/app/api/v1/api.rb:5:in `<class:API>'
	from /home/deploy/apps/golf/releases/20150909205712/app/api/v1/api.rb:4:in `<module:V1>'
	from /home/deploy/apps/golf/releases/20150909205712/app/api/v1/api.rb:3:in `<top (required)>'

```

If i run simple ```rails s ``` it works perfect ...

My experience (in case it helps anyone!):

To anyone who gets a javascript runtime error... I had to add these to my gemfile:

```
gem 'execjs'
gem 'therubyracer'
```

Also, if you have trouble with your .yml files (which are excluded from git for many), I added this to my deploy.rb:

```
  set :linked_files, %w{config/database.yml config/application.yml}
  ...
  namespace :deploy do
    desc 'Upload YAML files.'
    task :upload_yml do
      on roles(:app) do
        execute "mkdir #{shared_path}/config -p"
        upload! StringIO.new(File.read("config/database.yml")), "#{shared_path}/config/database.yml"
        upload! StringIO.new(File.read("config/application.yml")), "#{shared_path}/config/application.yml"
      end
    end
```

Then I did `rake:upload_yml` to upload those files.

I also had some weird bugs that surfaced in production when doing initial migrations thus did not exist locally in development. 

One gem conflicted with devise gem, the error pointed to the line that I needed to comment out, then did initial deploy again, then commented back once my database was set up with migrations.

Then I was trying to load a lib file with `require 'Libname'`. The actual lib file was `libname.rb` and thus should have been `require 'libname'`. I shouldn't have had the capital letter, but I didn't know that until now. It was not a problem locally in development probably because my local machine didn't require it to be case sensitive.

Good luck! These hiccups took many hours of searching and trial&error, but things look great now. Server seems speedy! Thanks DO!

Step 6 — Adding Deployment Configurations in the Rails App

Step 7 — Deploying your Rails Application

### Introduction

Rails is an open source web application framework written in Ruby. It follows the _Convention over Configuration_ philosophy by making assumptions that there is the 'best' way of doing things. This allows you to write less code while accomplishing more without having you go through endless config files.

Nginx is a high performance HTTP server, reverse proxy, and a load balancer known for its focus on concurrency, stability, scalability, and low memory consumption. Like Nginx, Puma is another extremely fast and concurrent web server with a very small memory footprint but built for Ruby web applications.

Capistrano is a remote server automation tool focusing mainly on Ruby web apps. It's used to reliably deploy web apps to any number of remote machines by scripting arbitrary workflows over SSH and automate common tasks such as asset pre-compilation and restarting the Rails server.

In this tutorial we'll install Ruby and Nginx on a DigitalOcean Ubuntu Droplet and configure Puma and Capistrano in our web app. Nginx will be used to capture client requests and pass them over to the Puma web server running Rails. We'll use Capistrano to automate common deployment tasks, so every time we have to deploy a new version of our Rails app to the server, we can do that with a few simple commands.


## Prerequisites

To follow this tutorial, you must have the following:

- Ubuntu 14.04 x64 Droplet
- A non-root user named `deploy` with sudo privileges ([Initial Server Setup with Ubuntu 14.04](https://www.digitalocean.com/community/tutorials/initial-server-setup-with-ubuntu-14-04) explains how to set this up.)
- Working Rails app hosted in a remote git repository that's ready to be deployed

Optionally, for heightened security, you can disable root login via SSH and change the SSH port number as described in [Initial Server Setup with Ubuntu 14.04](https://www.digitalocean.com/community/tutorials/initial-server-setup-with-ubuntu-14-04).

<$>[warning]
**Warning:** After disabling root login, make sure you can SSH to your Droplet as the `deploy` user and use `sudo` for this user *before* closing the root SSH session you opened to make these changes.
<$>

All the commands in this tutorial should be run as the `deploy` user. If root access is required for the command, it will be preceded by `sudo`. 

## Step 1 — Installing Nginx

Once the VPS is secure, we can start installing packages. Update the package index files:

```custom_prefix(deploy@droplet:~$)
sudo apt-get update
```
Then, install Nginx:

```custom_prefix(deploy@droplet:~$)
sudo apt-get install curl git-core nginx -y
```

## Step 2 — Installing Databases

Install the database that you'll be using in your Rails app. Since there are lots of databases to choose from, we won't cover them in this guide. You can see instructions for major ones here:

- [MySQL](https://www.digitalocean.com/community/tutorials/a-basic-mysql-tutorial)
- [PostgreSQL](https://www.digitalocean.com/community/tutorials/how-to-install-and-use-postgresql-on-ubuntu-14-04)
- [MongoDB](https://www.digitalocean.com/community/tutorials/how-to-install-mongodb-on-ubuntu-12-04)

Also be sure to check out:

-  [How To Use MySQL with Your Ruby on Rails Application on Ubuntu 14.04](https://www.digitalocean.com/community/tutorials/how-to-use-mysql-with-your-ruby-on-rails-application-on-ubuntu-14-04)
-  [How To Use PostgreSQL with Your Ruby on Rails Application on Ubuntu 14.04](https://www.digitalocean.com/community/tutorials/how-to-use-postgresql-with-your-ruby-on-rails-application-on-ubuntu-14-04)

## Step 3 — Installing RVM and Ruby

We won't be installing Ruby directly. Instead, we'll use a Ruby Version Manager. There are lots of them to choose from (rbenv, chruby, etc.), but we'll use RVM for this tutorial. RVM allows you to easily install and manage multiple rubies on the same system and use the correct one according to your app. This makes life much easier when you have to upgrade your Rails app to use a newer ruby.

Before installing RVM, you need to import the RVM GPG Key:

```custom_prefix(deploy@droplet:~$)
gpg --keyserver hkp://keys.gnupg.net --recv-keys 409B6B1796C275462A1703113804BB82D39DC0E3
```

Then install RVM to manage our Rubies:

```custom_prefix(deploy@droplet:~$)
curl -sSL https://get.rvm.io | bash -s stable
```

This command uses `curl` to download the RVM Installation script from `https://get.rvm.io`. The `-sSL` option is composed of three flags: 

- `-s` tells curl to download the file in 'silent mode'
- `-S` tells curl to show an error message if it fails
- `-L` tells curl to follow all HTTP redirects while retrieving the installation script

Once downloaded, the script is _piped_ to `bash`. The `-s` option passes `stable` as an argument to the RVM Installation script to download and install the stable release of RVM.


<$>[note]
**Note:** If the second command fails with the message "GPG signature verification failed", that means the GPG Key has changed, simply copy the command from the error output and run it to download the signatures. Then run the curl command for the RVM Installation.
<$>

We need to load the RVM script (as a function) so we can start using it. We then need to run the `requirements` command to automatically install required dependencies and files for RVM and Ruby to function properly:

```custom_prefix(deploy@droplet:~$)
source ~/.rvm/scripts/rvm
rvm requirements
```

We can now install the Ruby of our choice. We'll be installing the latest `Ruby 2.2.1` (at the time of writing) as our default Ruby:

```custom_prefix(deploy@droplet:~$)
rvm install 2.2.1
rvm use 2.2.1 --default
```

## Step 4 — Installing Rails and Bundler

Once Ruby is set up, we can start installing Rubygems. We'll start by installing the Rails gem that will allow your Rails application to run, and then we'll install `bundler` which can read your app's `Gemfile` and automatically install all required gems.  

To install Rails and Bundler:

```custom_prefix(deploy@droplet:~$)
gem install rails -V --no-ri --no-rdoc
gem install bundler -V --no-ri --no-rdoc
```

Three flags were used:

- `-V` (Verbose Output): Prints detailed information about Gem installation
- `--no-ri` - (Skips Ri Documentation): Doesn't install Ri Docs, saving space and making installation fast
- `--no-rdoc` - (Skips RDocs): Doesn't install RDocs, saving space and speeding up installation

<$>[note]
**Note:** You can also install a specific version of Rails according to your requirements by using the `-v` flag:

```custom_prefix(deploy@droplet:~$)
gem install rails <^>-v '4.2.0'<^> -V --no-ri --no-rdoc
```
<$>

## Step 5 — Setting up SSH Keys

Since we want to set up smooth deployments, we'll be using SSH Keys for authorization. First shake hands with GitHub, Bitbucket, or any other Git Remote where the codebase for your Rails app is hosted:

```custom_prefix(deploy@droplet:~$)
ssh -T git@github.com
ssh -T git@bitbucket.org
```

Don't worry if you get a `Permission denied (publickey)` message. Now, generate a SSH key (a Public/Private Key Pair) for your server:

```custom_prefix(deploy@droplet:~$)
ssh-keygen -t rsa 
```

Add the newly created public key (`~/.ssh/id_rsa.pub`) to your repository's deployment keys:

- [Instructions for Github](https://developer.github.com/guides/managing-deploy-keys/)
- [Instructions for Bitbucket](https://confluence.atlassian.com/display/BITBUCKET/Use+deployment+keys)

If all the steps were completed correctly, you should now be able to `clone` your git repository (over the SSH Protocol, not HTTP) without entering your password:

```custom_prefix(deploy@droplet:~$)
git clone <^>git@example.com:username/appname.git<^>
```

If you need a sample app for testing, you can fork the following test app specifically created for this tutorial: [Sample Rails App on GitHub](https://github.com/sheharyarn/testapp_rails)

The `git clone` command will create a directory with the same name as your app. For example, a directory named `testapp_rails` will be created. 

We are cloning only to check if our deployment keys are working, we don't need to clone or pull our repository every time we push new changes. We'll let Capistrano handle all that for us. You can now delete this cloned directory if you want to.

Open a terminal on your local machine. If you don't have a SSH Key for your local computer, create one for it as well. In your local terminal session:

```command
ssh-keygen -t rsa 
```

Add your local SSH Key to your Droplet's _Authorized Keys_ file (remember to replace the port number with your customized port number):

```command
cat ~/.ssh/id_rsa.pub | ssh -p <^>your_port_num<^> deploy@<^>your_server_ip<^> 'cat >> ~/.ssh/authorized_keys'
```

## Step 6 — Adding Deployment Configurations in the Rails App

On your local machine, create configuration files for Nginx and Capistrano in your Rails application. Start by adding these lines to the `Gemfile` in the Rails App:

```
[label Gemfile]

group :development do
    gem 'capistrano',         require: false
    gem 'capistrano-rvm',     require: false
    gem 'capistrano-rails',   require: false
    gem 'capistrano-bundler', require: false
    gem 'capistrano3-puma',   require: false
end

gem 'puma'
```

Use `bundler` to install the gems you just specified in your `Gemfile`. Enter the following command to bundle your Rails app:

```command
bundle
```

After bundling, run the following command to configure Capistrano:

```command
cap install
```

This will create:

- `Capfile` in the root directory of your Rails app
- `deploy.rb` file in the `config` directory
- `deploy` directory in the `config` directory

Replace the contents of your `Capfile` with the following:

```
[label Capfile]
# Load DSL and Setup Up Stages
require 'capistrano/setup'
require 'capistrano/deploy'

require 'capistrano/rails'
require 'capistrano/bundler'
require 'capistrano/rvm'
require 'capistrano/puma'

# Loads custom tasks from `lib/capistrano/tasks' if you have any defined.
Dir.glob('lib/capistrano/tasks/*.rake').each { |r| import r }
```

This `Capfile` loads some pre-defined tasks in to your Capistrano configuration files to make your deployments hassle-free, such as automatically:

- Selecting the correct Ruby
- Pre-compiling Assets
- Cloning your Git repository to the correct location
- Installing new dependencies when your Gemfile has changed 

Replace the contents of `config/deploy.rb` with the following, updating fields marked in red with your app and Droplet parameters: 

```
[label config/deploy.rb]

# Change these
server <^>'your_server_ip'<^>, port: <^>your_port_num<^>, roles: [:web, :app, :db], primary: true

set :repo_url,        <^>'git@example.com:username/appname.git'<^>
set :application,     <^>'appname'<^>
set :user,            <^>'deploy'<^>
set :puma_threads,    [4, 16]
set :puma_workers,    0

# Don't change these unless you know what you're doing
set :pty,             true
set :use_sudo,        false
set :stage,           :production
set :deploy_via,      :remote_cache
set :deploy_to,       "/home/#{fetch(:user)}/apps/#{fetch(:application)}"
set :puma_bind,       "unix://#{shared_path}/tmp/sockets/#{fetch(:application)}-puma.sock"
set :puma_state,      "#{shared_path}/tmp/pids/puma.state"
set :puma_pid,        "#{shared_path}/tmp/pids/puma.pid"
set :puma_access_log, "#{release_path}/log/puma.error.log"
set :puma_error_log,  "#{release_path}/log/puma.access.log"
set :ssh_options,     { forward_agent: true, user: fetch(:user), keys: %w(~/.ssh/id_rsa.pub) }
set :puma_preload_app, true
set :puma_worker_timeout, nil
set :puma_init_active_record, true  # Change to false when not using ActiveRecord

## Defaults:
# set :scm,           :git
# set :branch,        :master
# set :format,        :pretty
# set :log_level,     :debug
# set :keep_releases, 5

## Linked Files & Directories (Default None):
# set :linked_files, %w{config/database.yml}
# set :linked_dirs,  %w{bin log tmp/pids tmp/cache tmp/sockets vendor/bundle public/system}

namespace :puma do
  desc 'Create Directories for Puma Pids and Socket'
  task :make_dirs do
    on roles(:app) do
      execute "mkdir #{shared_path}/tmp/sockets -p"
      execute "mkdir #{shared_path}/tmp/pids -p"
    end
  end

  before :start, :make_dirs
end

namespace :deploy do
  desc "Make sure local git is in sync with remote."
  task :check_revision do
    on roles(:app) do
      unless `git rev-parse HEAD` == `git rev-parse origin/master`
        puts "WARNING: HEAD is not the same as origin/master"
        puts "Run `git push` to sync changes."
        exit
      end
    end
  end

  desc 'Initial Deploy'
  task :initial do
    on roles(:app) do
      before 'deploy:restart', 'puma:start'
      invoke 'deploy'
    end
  end

  desc 'Restart application'
  task :restart do
    on roles(:app), in: :sequence, wait: 5 do
      invoke 'puma:restart'
    end
  end

  before :starting,     :check_revision
  after  :finishing,    :compile_assets
  after  :finishing,    :cleanup
  after  :finishing,    :restart
end

# ps aux | grep puma    # Get puma pid
# kill -s SIGUSR2 pid   # Restart puma
# kill -s SIGTERM pid   # Stop puma
```

This `deploy.rb` file contains some sane defaults that work out-of-the-box to help you manage your app releases and automatically perform some tasks when you make a deployment:

- Uses `production` as the default environment for your Rails app
- Automatically manages multiple releases of your app
- Uses optimized SSH options
- Checks if your git remotes are up to date
- Manages your app's logs
- Preloads the app in memory when managing Puma workers
- Starts (or restarts) the Puma server after finishing a deployment
- Opens a socket to the Puma server at a specific location in your release

You can change all options depending on your requirements. Now, Nginx needs to be configured. Create `config/nginx.conf` in your Rails project directory, and add the following to it (again, replacing with your parameters):

```
[label config/nginx.conf]

upstream puma {
  server unix:///home/<^>deploy<^>/apps/<^>appname<^>/shared/tmp/sockets/<^>appname<^>-puma.sock;
}

server {
  listen 80 default_server deferred;
  # server_name example.com;

  root /home/<^>deploy<^>/apps/<^>appname<^>/current/public;
  access_log /home/<^>deploy<^>/apps/<^>appname<^>/current/log/nginx.access.log;
  error_log /home/<^>deploy<^>/apps/<^>appname<^>/current/log/nginx.error.log info;

  location ^~ /assets/ {
    gzip_static on;
    expires max;
    add_header Cache-Control public;
  }

  try_files $uri/index.html $uri @puma;
  location @puma {
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header Host $http_host;
    proxy_redirect off;

    proxy_pass http://puma;
  }

  error_page 500 502 503 504 /500.html;
  client_max_body_size 10M;
  keepalive_timeout 10;
}
```

Like the previous file, this `nginx.conf` contains defaults that work out-of-the-box with the configurations in your `deploy.rb` file. This listens for traffic on port 80 and passes on the request to your Puma socket, writes nginx logs to the 'current' release of your app, compresses all assets and caches them in the browser with maximum expiry, serves the HTML pages in the public folder as static files, and sets default maximum `Client Body Size` and `Request Timeout` values. 

## Step 7 — Deploying your Rails Application

If you are using your own Rails app, commit the changes you just made, and push them to remote from your Local Machine:

```command
git add -A
git commit -m "Set up Puma, Nginx & Capistrano"
git push origin master
```

<$>[note]
**Note:** If this is the first time using GitHub from this system, you might have to issue the following commands with your GitHub username and email address:

```command
git config --global user.name 'Your Name'
git config --global user.email you@example.com
```
<$>


Again, from your local machine, make your first deployment:

```command
cap production deploy:initial
```

This will push your Rails app to the Droplet, install all required gems for your app, and start the Puma web server. This may take anywhere between 5-15 minutes depending on the number of Gems your app uses. You will see debug messages as this process occurs.

If everything goes smoothly, we're now ready to connect your Puma web server to the Nginx reverse proxy.

On the Droplet, Symlink the `nginx.conf` to the `sites-enabled` directory:

```custom_prefix(deploy@droplet:~$)
sudo rm /etc/nginx/sites-enabled/default
sudo ln -nfs "/home/<^>deploy<^>/apps/<^>appname<^>/current/config/nginx.conf" "/etc/nginx/sites-enabled/<^>appname<^>"
```

Restart the Nginx service:

```custom_prefix(deploy@droplet:~$)
sudo service nginx restart
```

You should now be able to point your web browser to your server IP and see your Rails app in action!

## Normal Deployments

Whenever you make changes to your app and want to deploy a new release to the server, commit the changes, push to your git remote like usual, and run the `deploy` command:

```command
git add -A
git commit -m "Deploy Message"
git push origin master
cap production deploy
```

<$>[note]
**Note:** If you make changes to your `config/nginx.conf` file, you'll have to reload or restart your Nginx service on the server after deploying your app:

```custom_prefix(deploy@droplet:~$)
sudo service nginx restart
```
<$>

## Conclusion

Okay, so by now you would be running a Rails app on your Droplet with Puma as your Web Server as well as Nginx and Capistrano configured with basic settings. You should now take a look at other docs that can help you optimize your configurations to get the maximum out of your Rails application:

- [Puma Configurations](https://github.com/puma/puma/) 
- [Puma DSL in Capistrano](https://github.com/seuros/capistrano-puma)
- [Local Asset Pre-compilation in Capistrano](https://github.com/stve/capistrano-local-precompile)
- [Automatically restart Puma workers based on RAM](https://github.com/schneems/puma_worker_killer)
- [Optimizing Nginx for High Traffic Loads](https://blog.martinfjordvald.com/2011/04/optimizing-nginx-for-high-traffic-loads/)


In this tutorial we'll install Ruby and Nginx on a DigitalOcean Ubuntu Droplet and configure Puma and Capistrano in our web app. Nginx will be used to capture client requests and pass them over to the Puma web server running Rails. We'll use Capistrano to automate common deployment tasks, so every time we have to deploy a new version of our Rails app to the server, we can do that with a few simple commands.