Pages

Thursday, 10 April 2014

Capistrano Details

Capistrano is a Ruby gem or we can say a set of Ruby programs that gives you a set
of advanced tools to deploy web applications to web servers. In other
words, Capistrano allows you to copy code from your source control
repository (SVN/Git) to your server via SSH, and perform pre and
post-deploy functions like restarting a web server, renaming files,
running database migrations and so on. With Capistrano you can also
deploy to many machines at once.
  • Capistrano
    offers many advanced options but for the purpose of this introductory
    blog, we will focus only on the essential things that need to be taken
    care of while deploying a simple app. We will setup a simple
    recipe(fancy name for capistrano scripts) for deploying a Rails
    application to a single server from either SVN or Git repositories. We
    will cover a common workflow that allows you to deploy multiple
    environments: in this case, staging and production.
  • This tutorial has three steps for deployment
  • Installing Capistrano
  • Configure
  • Deployment
So Let’s start with the steps:-
1. Installing Capistrano:- In order to install Capistrano you will need Ruby and RubyGems
installed on your computer. Then, just open the Gemfile of your Rails
application and add the following line to include the capistrano gem:-

gem 'capistrano'
After configuring the gemfile, run ‘bundle install‘ command.
2. Configure:
2.1. Capification
:- Capification refers to generating the necessary files in your Rails
application needed for the deployment and this can be done by firing the
following command in your rails app directory:-
ubuntu:~/app_directory$ capify
This command will create two files:
  • Capfile:
    this is the “main” file that Capistrano needs. Capistrano looks for and
    loads “Capfile” by default. All it does is load “config/deploy.rb”.
  • config/deploy.rb:
    this is the file that contains your Rails application’s deployment
    configuration. Rails prefers that all configuration go under the config
    directory, and so Capistrano tries to abide by that as much as it can by
    just pointing the Capfile to config/deploy.rb.
2.2. Configuration
:- In general, you’ll leave the Capfile alone and do all your tweaking
in config/deploy.rb. So for now just leave the Capfile and start working
with the deploy.rb file. The following are the essential elements which
are needed to be include for basic deployment:-
  • set :application, “App_Name” /* The name of your application to be deployed*/
  • set
    :repository, “repository_address” /*address of the repository where the
    application resides. This repository must be accessible to the
    server(where we are deploying) as well as the local machine*/
  • set
    :scm, :git /*we need to tell capistrano about which SCM we are using
    e.g. GIT, SVN or any other SCM. In above example we are using GIT. if we
    don’t write the SCM then by default it takes it as SVN. if you use
    username and password to access your repository then you need to mention
    that also by using the following two attributes also*/
  • set :scm_username, ‘your_scm_username’
  • set :scm_password, ‘your_scm_password’
  • set :deploy_to, “/data/#{application}” /*the address on the server where you want to deploy your application*/
  • set :user, “username” /*username for ssh login into remote server where you want to deploy your application*/
  • set
    :password, “password” /* for ssh login into remote server where you
    want to deploy your application. If you are not having the password you
    can you your public key to login into the server by giving the following
    option*/
  • ssh_options[:keys] = ["Your ssh key full path and name"]
  • server
    “abcd.com”, :app, :web, :db, :primary => true /*name or IP address
    of server where we want to deploy our application. But if we want to
    deploy the application on mltiple servers, then we need to add the
    following */
  • role :app, “tutorial.com”
  • role :web, “tutorial.com”
  • role :db, “tutorial.com”, :primary => true
Those
three roles (app, web, and db) are the three that Capistrano needs for
Rails deployment. You can always add your own roles, too, for tasks of
your own, but make sure you declare at least one server in each of app,
web, and db when you’re deploying Rails applications.
  • web:
    this is where your web server software runs. Requests from the web go
    straight here. For sites with lots of traffic, you might have two or
    three (or more!) web servers running behind a load balancer.
  • app:
    this is where your application layer runs. You might need only a single
    web server, and have it send requests to any of four or five different
    app servers, via a load balancer.
  • db:
    this is where migrations are run. Some prefer not to actually run code
    on the server where the database lives, so you can just set this to one
    of the app servers if you prefer. Capistrano will deploy your
    application to servers in this role. The “:primary => true” bit just
    says that this is our “primary” database server—you can have as many as
    you want (for database slaves and so forth), but Capistrano will only
    run migrations on the one you designate as “primary”.
The addresses you place in each role are the addresses that Capistrano will SSH to, in order to execute the commands you give.
By
using these parameters one can easily deploy a simple app to server.
And there are some parameter which gives you additional options like:
  • use_sudo:
    Defines for the default Rails deployment recipes whether we want to use
    sudo or not. Sudo is a unix tool for executing commands as the
    root_user . To use it, your user must have passwordless sudo access
    enabled. If you’re using shared hosting where sudo access may not be
    enabled for your user, you should set :use_sudo to false. In general, if
    you can get away without using sudo, you should avoid it.
  • keep_releases:
    The number of old releases to keep, defaults to 5, can be overridden
    with any positive integer, negative values will produce undefined
    behavior. 0 means zero.
  • git_enable_submodules:
    If you’re using git submodules you must tell cap to fetch them or not.
    You can set its value 1 to include it and 0 to not include it.
  • branch:-
    You need to tell cap the branch to checkout during deployment. For
    example we have two branches i.e master and production and you want to
    check out from master branch, then you will be write it as:
  • set :branch, “master”
  • deploy_via:-
    This option is used to tell capistrano that which deployment strategy
    we are using for deployment. There are various options available with
    deploy_via and we can chose between them as our convenience.
  • :checkout will do a full SCM checkout.
  • :copy will checkout locally, then tar and gzip the copy and sftp it to the remote servers.
  • :remote_cache
    will keep a local git repo on the server you’re deploying to and simply
    run a fetch from that rather than an entire clone. This is probably the
    best option as it will only fetch the changes since the last deploy.
  • Deployment
  • Everything
    is ready to try our recipe for the first time and let Capistrano create
    the initial directory structure on your server for future deployments.
    Run the following command from the root directory of your application:
  • cap deploy:setup cap deploy:setup
  • When
    you run this command, Capistrano will SSH to your server, enter the
    directory that you specified in the deploy_to variable, and create a
    special directory structure that’s required for Capistrano to work
    properly. If something is wrong with the permissions or SSH access, you
    will get error messages. Look closely at the output Capistrano gives you
    while the command is running.
  • The
    last step before we can do an actual deployment with Capistrano is to
    make sure that everything is set up correctly on the server from the
    setup command. There’s a simple way to verify, with the command:
  • cap deploy:check cap deploy:check
  • This
    command will check your local environment and your server and locate
    likely problems. If you see any error messages, fix them and run the
    command again. Once you can run without errors, you can proceed!Once
    you’ve verified your local and server configuration, run the following
    command:
  • cap production deploy:migrations
  • This command just log in to production and deploy the latest code from the master branch and run all the pending migrations.
  • cap deploy
  • This
    will perform a deployment to your default stage, which is staging. If
    you want to deploy to production, you’d run the following:
  • cap production deploy production deploy
  • While
    these commands are performed, you will see a lot of output. Capistrano
    print all commands it runs on your server as well as their output,
    making it possible for you to debug any problems. Enjoy the dynamic
    deployments using capistrano !!