How To Automate Ruby On Rails Application Deployments Using Capistrano

Tired of repetitive, mundane tasks when deploying your Ruby on Rails applications? Manual server updates, code uploads, and configuration changes can drain your development joy. Capistrano, a powerful task automation tool, is here to streamline your deployment process.

This guide builds upon previous knowledge from “Automating Deployments With Capistrano: Getting Started” and “How To Deploy Rails Apps Using Passenger With Nginx on CentOS 6.5.” It will walk you through setting up a robust CentOS server environment with Nginx and Passenger, and then automating deployments using Capistrano.

Prerequisites:

• Familiarity with Git (see DigitalOcean’s Git resources).
• Understanding of basic server administration.
• Prior knowledge of Capistrano (recommended: read the introductory article).
• Knowledge of deploying Rails apps with Passenger and Nginx.

Glossary

• Capistrano: A Ruby-based automation tool for application deployment.
• CentOS: A Linux distribution used for the deployment server.
• Nginx: A high-performance web server.
• Passenger: A web application server that integrates with Nginx.
• RVM: Ruby Version Manager.
• EPEL: Extra Packages for Enterprise Linux.
• Git: A distributed version control system.

1. Preparing The Deployment Server

1.1 Updating And Preparing The Operating System

1. Update system packages: $ yum -y update
2. Install development tools: $ yum groupinstall -y 'development tools'
3. Add the EPEL repository: $ sudo su -c 'rpm -Uvh http://dl.fedoraproject.org/pub/epel/6/x86_64/epel-release-6-8.noarch.rpm'
4. Update again: $ yum -y update
5. Install necessary libraries: $ yum install -y curl-devel nano sqlite-devel libyaml-devel

1.2 Setting Up Ruby Environment and Rails

1. Install RVM: $ curl -L get.rvm.io | bash -s stable
2. Source RVM: $ source /etc/profile.d/rvm.sh
3. Reload RVM: $ rvm reload
4. Install Ruby 2.1.0: $ rvm install 2.1.0
5. Install Node.js: $ yum install -y nodejs
6. Install Bundler and Rails: $ gem install bundler rails

1.3 Downloading And Installing App. & HTTP Servers

• Swap Space (if needed):
  • Create swap file: $ sudo dd if=/dev/zero of=/swap bs=1M count=1024
  • Format swap file: $ sudo mkswap /swap
  • Enable swap: $ sudo swapon /swap
• Phusion Passenger:
  • Install Passenger: $ gem install passenger
• Nginx:
  • Compile Nginx with Passenger module: $ passenger-install-nginx-module (Follow on-screen instructions).

1.4 Creating The Nginx Management Script

1. Create script: $ nano /etc/rc.d/init.d/nginx
2. Paste the provided script content.
3. Make script executable: $ chmod +x /etc/rc.d/init.d/nginx

1.5 Configuring Nginx For Application Deployment

1. Edit Nginx configuration: $ nano /opt/nginx/conf/nginx.conf
2. Add passenger_app_env development; in the http block (for testing).
3. Comment out the default location / block.
4. Set application root and enable Passenger:
   Nginx

   root /home/deployer/apps/my_app/public;
   passenger_enabled on;
   

5. Restart Nginx: $ /etc/init.d/nginx restart
6. Check Nginx status: $ /etc/init.d/nginx status

1.6 Downloading And Installing Capistrano

• Install Capistrano: $ gem install capistrano

1.7 Creating A System User For Deployment

1. Add user: $ adduser deployer
2. Set password: $ passwd deployer
3. Grant sudo privileges: $ nano /etc/sudoers
4. Add deployer ALL=(ALL) ALL.

2. Preparing Rails Applications For Git-Based Capistrano Deployment

2.1 Creating A Basic Ruby-On-Rails Application

1. Create application: $ rails new my_app
2. Enter directory: $ cd my_app
3. Generate scaffold: $ rails generate scaffold Task title:string note:text
4. Migrate database: $ RAILS_ENV=development rake db:migrate
5. Start server (for testing): $ rails s

2.2 Creating A Git Repository

1. Initialize repository: $ git init
2. Add files: $ git add .
3. Commit changes: $ git commit -m "first commit"
4. Add remote: $ git remote add origin git@github.com:user123/my_app.git
5. Generate SSH key: $ ssh-keygen -t rsa
6. Add SSH key to GitHub.
7. Set Git user info:
   • $ git config --global user.name "user123"
   • $ git config --global user.email "user123@domain.tld"
8. Push to GitHub: $ git push -u origin master

3. Working With Capistrano To Automate Deployments

3.1 Installing Capistrano Inside The Project Directory

• Install Capistrano files: $ cap install

3.2 Working With config/deploy.rb Inside The Project Directory

1. Edit config/deploy.rb: $ nano config/deploy.rb
2. Add application settings:
   Ruby

   set :application, 'my_app'
   set :scm, :git
   set :repo_url, 'https://github.com/user123/my_app.git'
   set :deploy_to, "/home/deployer/apps/my_app"
   set :pty, true
   set :format, :pretty
   

3.3 Working With config/deploy/production.rb Inside The Project Directory

1. Edit config/deploy/production.rb: $ nano config/deploy/production.rb
2. Add server settings:
   Ruby

   role :app, %w{deployer@162.243.74.190}
   role :web, %w{deployer@162.243.74.190}
   role :db, %w{deployer@162.243.74.190}
   server '162.243.74.190', user: 'deployer', roles: %w{web}
   set :ssh_options, {
     forward_agent: false,
     auth_methods: %w(password),
     password: 'user_deployers_password',
     user: 'deployer',
   }
   

3.4 Deploying To The Production Server

• Deploy: $ cap production deploy

This single command, executed from your local development machine within your Rails application’s directory, triggers the entire Capistrano deployment process. Here’s what happens behind the scenes:

1. Connection to the Deployment Server:

• SSH Connection: Capistrano uses SSH (Secure Shell) to connect to your production server. The connection details (hostname/IP address, username, password or SSH key) are obtained from the config/deploy/production.rb file.
• Authentication: Capistrano authenticates using the specified method (password or SSH key). In the provided example, password authentication is used. For better security, SSH keys are strongly recommended.

2. Source Code Retrieval:

• Git Repository Access: Capistrano accesses your application’s source code from the Git repository specified in config/deploy.rb.
• Code Cloning/Updating:
  • If this is the first deployment, Capistrano clones the repository to the deployment server.
  • For subsequent deployments, it fetches the latest changes from the repository.
• Branch/Tag Selection: Capistrano can be configured to deploy a specific branch or tag. By default, it deploys the master branch.

3. Deployment Process:

• Release Creation: Capistrano creates a new release directory on the server, typically within the releases directory inside the deploy_to path. Each release is timestamped, allowing you to easily roll back to previous versions.
• Code Deployment: The source code is copied into the new release directory.
• Dependency Installation: Capistrano executes bundle install to install the required Ruby gems based on your application’s Gemfile.
• Database Migrations: If your application uses a database, Capistrano can automatically run database migrations using rake db:migrate.
• Asset Precompilation: For Rails applications, Capistrano precompiles assets (CSS, JavaScript) using rake assets:precompile.
• Symbolic Linking: Capistrano creates symbolic links to shared resources (e.g., database configuration files, uploaded files) from the release directory.
• Current Release Update: Capistrano updates the current symbolic link to point to the new release directory, effectively making the new version live.

4. Post-Deployment Tasks:

• Application Restart: Capistrano can be configured to restart your application server (e.g., Passenger, Puma) to load the new code.
• Custom Tasks: You can define custom tasks in your config/deploy.rb file to perform any additional actions required for your application, such as clearing caches or running specific scripts.
• Cleanup: Capistrano typically cleans up old releases, keeping only a specified number of recent deployments.

In essence, the cap production deploy command automates the following:

• Connecting to your production server.
• Retrieving the latest code.
• Setting up the application in a new release directory.
• Installing dependencies and running necessary tasks.
• Switching the current release to the new version.
• Restarting the application.

This automation significantly reduces the risk of errors and streamlines the deployment process, allowing you to deploy your applications quickly and reliably.