nginx+unicorn deploy ruby ​​web environment

I recently took over a ruby ​​web project. Since I have never been exposed to ruby ​​and related web development before, and the documentation in the project is missing, I took some detours when deploying the project. Finally, I successfully deployed the project by referring to multiple ruby ​​on rails development environment deployments and learning the relationship between gems/bundlers in ruby. Write it down here, it is a small summary, and it can also provide a reference for the deployment environment when you are just getting started with ruby ​​web development.
Our project is based on padrino. If it is a rails-based project, the deployment should be similar.

1. Install ruby ​​

Since there may be multiple ruby-related projects in the system, and different projects may need to be developed or tested for different ruby ​​versions, multiple ruby ​​versions may need to be installed in the system . This requires corresponding tools to manage existing versions and install new versions. I choose rbenv here, but you can also use the old rvm.
Install rbenv

git clone git://github.com/sstephenson/rbenv.git  ~/.rbenv
echo 'export PATH="$HOME/.rbenv/bin:$PATH"' >> ~/.bashrc
echo 'eval "$(rbenv init -)"' >> ~/.bashrc
exec $SHELL

Add ruby-build component

git clone git://github.com/sstephenson/ruby-build.git ~/.rbenv/plugins/ruby-build
echo 'export PATH="$HOME/.rbenv/plugins/ruby-build/bin:$PATH"' >> ~/.bashrc
exec $SHELL

Add gem-rehash component

git clone https://github.com/sstephenson/rbenv-gem-rehash.git ~/.rbenv/plugins/rbenv-gem-rehash

Install ruby ​​(take ruby2.1.5 as an example)
Since the default installation of ruby ​​will be slower, so download the corresponding one from ruby.taobao.org first file, and then use local installation to install

wget -O ~/.rbenv/versions/ruby-2.1.5.tar.gz http://ruby.taobao.org/mirrors/ruby/2.1/ruby-2.1.5.tar.gz
env RUBY_BUILD_MIRROR_URL=file:///home/ziven/.rbenv/versions/ruby-2.1.5.tar.gz# ~/.rbenv/bin/rbenv install 2.1.5

where wget is to download the corresponding ruby ​​file, here is ruby-2.1.5.tar.gz

RUBY_BUILD_MIRROR_URL

is used to specify the installed ruby ​​image path, here the local path is used directly. Note that the local path should be ended with #. The version following the rbenv install command should correspond to the ruby ​​version to be installed. For example, the installed version may have a corresponding patch number (for example: 1.9.3-p223). This should also be written.

2. Install necessary components

Because we generally use bundler to manage the gems needed for the project, bundler needs to be installed here.

Considering the speed of connecting ruby ​​mirrors in China, we changed the gem source to taobao source.

gem sources --remove https://rubygems.org/
gem sources -a https://ruby.taobao.org/

After executing gem sources -l, there should be only one source: https://ruby.taobao.org/
Install bundler

gem install bundler

3. Application deployment

a. Clone web source code to the appropriate location

Here we assume that after cloning Place the source code to /opt/projectA

b. Install dependent gems

Execute in the root directory of the project:

bundle install

It should be noted here that the commands executed may be slightly different depending on the situation. For example, when deploying in a production environment, you may need to execute

bundle install --deployment --without development test

. When deploying like this, the relevant dependent gems are installed under projectA/vendor/bundle. It is especially suitable for use when different projects depend on different versions of the same gem.

c. Database related migration

Since this project is based on padrino, it needs to be executed:

padrino rake --envir db:migrate

It should be noted that depending on the situation, you may need to use bundle to execute this command:

bundle exec padrino rake --envir db:migrate

After the database migration is successful, you need to create an amdin account. Padrino completes the creation of the admin account in db/seeds.rb by default. So execute here:

bundle exec padrino rake --envir seed

will prompt you to enter the email address and password of the admin account during the execution process

d.unicorn deployment

You may need the corresponding unicorn startup script here, which can be written by referring to ruby-china's unicorn.rb. Omitted here.

Start unicorn server:

bundle exec unicorn -E production -c unicorn.rb -D

so padrino server has started normally. If unicorn.rb is listening on the tcp port, then you should be able to access the corresponding URL at this time. If you use the method of monitoring unix socket, you should also use nginx (or apache) as a reverse proxy.

4. nginx installation configuration

a. nginx installation

nginx can be installed in the same way as general Linux software. It is recommended to use the source code installation method. For the sake of simplicity here, we will temporarily install it using the package manager installation method:

sudo apt-get install nginx-full

b. nginx configuration

	upstream myserver {
	  server unix:/tmp/projectA.sock fail_timeout=0;
	}
	
	server {
	    listen       7788;
	    server_name  localhost;
	
	    client_max_body_size 10M;
	
	    error_page   500 502 503 504  /50x.html;
	    location = /50x.html {
	        root   /usr/share/nginx/html;
	    }
	
	    root /opt/projectA/web/public;
	
	    try_files $uri $uri.html @app;
	
	    location @app {
	        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
	        proxy_set_header Host $http_host;
	        proxy_redirect off;
	        proxy_pass http://myserver;
	    }
	}

Here, the request for port 7788 is forwarded to

unix:/tmp/projectA.sock

for processing. That is, it is forwarded to our web server just now for processing. At this point, the server is running normally. Other auxiliary functions can be added as needed. For example, nginx may require an SSL certificate for authentication.
The deployment of ruby ​​on rails projects is similar. During the deployment process, you may need to make corresponding adjustments according to the situation when executing the corresponding commands. However, as long as you are familiar with the deployment method of ruby ​​web, it is relatively easy to deploy other documents that can be referred to related frameworks.

The above introduces nginx+unicorn deployment of ruby ​​web environment, including aspects of the content. I hope it will be helpful to friends who are interested in PHP tutorials.