RVM, Ruby on Rails, Unicorn y Nginx: te enseñamos cómo instalarlos en Ubuntu 16.04

En Clouding.io nos gusta darte info de utilidad para tu Cloud Server. En este tutorial te vamos a enseñar cómo instalar RVM, Ruby on Rails, Unicorn y NGINX en Ubuntu 16.04 en unos sencillos pasos. Vamos allá :)

Instalación de RVM en Ubuntu 16.04

Tienes que utilizar el siguiente paquete:

# apt-add-repository -y ppa:rael-gc/rvm
# apt update
# apt install rvm nodejs

Crea el usuario ror y lo añádelo al grupo rvm:

# adduser ror --ingroup rvm

Añade el usuario ror al grupo sudo:

# usermod -G sudo ror

Edita el fichero /etc/ssh/sshd_config y en la última linea añade al usuario ror en los
AllowUsers

AllowUsers root ror

Por último, reinicia el servicio de ssh:

# service ssh restart

Instalación de Ruby on Rails en Ubuntu 16.04

Inicia sesión con el usuario ror e instala ruby 2.1.3:

$ rvm install 2.1.3
$ rvm use 2.1.3

Verifica que realmente se ha activado esta versión del siguiente modo:

$ ruby -v
ruby 2.1.3p242 (2014-09-19 revisión 47630) [x86_64-linux]

Por último, instala Rails 3.2.19 aún como usuario ror:

$ gem install rails -v 3.2.19

Instalación de Unicorn en Ubuntu 16.04

En primer lugar, como usuario ror debes instalar unicorn:

$ gem install unicorn

En segundo lugar, como usuario root, crea las diversas carpetas que vas a utilizar y continuación haz owner al usuario ror:

# mkdir -p /var/ror/app/shared /var/ror/unicorn/config /var/log/unicorn /var/run/unicorn /etc/unicorn/
# chown -R ror:rvm /var/ror/.
# chown -R ror:rvm /var/ror/*
# chown -R ror:rvm /var/log/unicorn/.
# chown -R ror:rvm /var/run/unicorn/.

Como usuario ror de nuevo, crea el fichero /var/ror/unicorn/config/unicorn.rb dejandolo así:


# set path to the application
app_dir = File.expand_path("/var/ror/app/current", __FILE__)
shared_dir = "#{app_dir}/shared"
working_directory app_dir

# Set unicorn options
worker_processes 2
preload_app true
timeout 30

# Path for the Unicorn socket
listen "/var/run/unicorn/unicorn.sock", :backlog => 64

# Set path for logging
stderr_path "/var/log/unicorn/stderr.log"
stdout_path "/var/log/unicorn/stdout.log"

# Set proccess id path
pid "/var/run/unicorn/unicorn.pid"

A continuación, como usuario root, crea el fichero /etc/init.d/unicorn con el siguiente contenido:


### BEGIN INIT INFO
# Required-Start
# Required-Stop
# Default-Start
# Default-Stop
# Short-Description
# Description: Enable at boot time
### END INIT INFO

# This is /etc/init.d/unicorn_init (without .sh)
# init.d script for single or multiple unicorn installations. Expects at least one .conf
# file in /etc/unicorn
#
# Forked from https://gist.github.com/zewelor/2623205
# based on modified version by http://github.com/killercup
# which based on modified version by jay@gooby.org http://github.com/jaygooby
# which is based on http://gist.github.com/308216 by http://github.com/mguterl
#
## A sample /etc/unicorn/my_app.conf
##
## RAILS_ENV=production
## RAILS_ROOT=/var/apps/www/my_app/current
## UNICORN="/usr/local/rvm/bin/<WRAPPED_NAME>" #see rvm wrapper above
## APP_USER="some_user"
## UNICORN_CONFIG="/var/apps/www/my_app/shared/config/unicorn.rb"
#
# This configures a unicorn master for your app at /var/apps/www/my_app/current running in
# production mode. It will read config/unicorn.rb for further set up.
#
# You should ensure different ports or sockets are set in each config/unicorn.rb if
# you are running more than one master concurrently.
#
# If you call this script without any config parameters, it will attempt to run the
# init command for all your unicorn configurations listed in /etc/unicorn/*.conf
#
# /etc/init.d/unicorn start # starts all unicorns
#
# If you specify a particular config, it will only operate on that one
#
# /etc/init.d/unicorn start my_app
export rvmsudo_secure_path=1
RVM_FILE_TO_SOURCE="/usr/share/rvm/scripts/rvm"
sig () {
test -s "$PID" && kill -$1 `cat "$PID"`
}

oldsig () {
test -s "$OLD_PID" && kill -$1 `cat "$OLD_PID"`
}

cmd () {

case $1 in
start)
sig 0 && echo >&2 "Already running" && return 0
eval $CMD
echo "Starting"
;;
stop)
sig QUIT && echo "Stopping" && return 0
echo >&2 "Not running"
;;
force-stop)
sig TERM && echo "Forcing a stop" && return 0
echo >&2 "Not running"
;;
restart|reload)
sig USR2 && sleep 5 && oldsig QUIT && echo "Killing old master" `cat $OLD_PID` && return 0
echo >&2 "Couldn't reload, starting '$CMD' instead"
eval $CMD
;;
upgrade)
sig USR2 && echo Upgraded && return 0
echo >&2 "Couldn't upgrade, starting '$CMD' instead"
eval $CMD
;;
rotate)
sig USR1 && echo rotated logs OK && return 0
echo >&2 "Couldn't rotate logs" && return 1
;;
*)
echo >&2 "Usage: $0 <start|stop|restart|upgrade|rotate|force-stop>"
exit 1
;;
esac
}

setup () {
CONFIG=$1

export APP_NAME=`basename $1|cut -f 1 -d '.'`

echo "Launching ${APP_NAME}"

if [ -z $APP_USER ]; then
if [ `/bin/egrep -i "^${APP_NAME}" /etc/passwd|wc -l` -eq 1 ]; then
export APP_USER=$APP_NAME
else
echo "The is no user defined in ${CONFIG}, and the is no user in the system called ${APP_NAME}"
return 1
fi
fi

if [ -z $RAILS_ROOT ]; then
if [ -d "/home/${APP_USER}/www/current" ]; then
export RAILS_ROOT="/home/${APP_USER}/www/current"
else
echo "Rails root is not defined in ${CONFIG}"
return 1
fi
fi

if [ -z $RAILS_ENV ]; then
export RAILS_ENV="production"
fi

# If unicorn binary was not defined in config
if [ -z "$UNICORN" ]; then
UNICORN="unicorn_rails"
fi

# If unicorn config was not defined in config
if [ -z $UNICORN_CONFIG ]; then
UNICORN_CONFIG=${RAILS_ROOT}/config/unicorn/${RAILS_ENV}.rb
fi

cd $RAILS_ROOT || return 1
export PID=$RAILS_ROOT/tmp/pids/unicorn.pid
export OLD_PID="$PID.oldbin"

CMD="rvmsudo -u ${APP_USER} ${UNICORN} -E ${RAILS_ENV} -c ${UNICORN_CONFIG} -D"
return 0
}

# either run the start/stop/reload/etc command for every config under /etc/unicorn
# or just do it for a specific one

# $1 contains the start/stop/etc command
# $2 if it exists, should be the specific config we want to act on
source $RVM_FILE_TO_SOURCE

if [ $2 ]; then
. /etc/unicorn/$2.conf
setup "/etc/unicorn/$2.conf"
if [ $? -eq 1 ]; then
exit
fi
cmd $1
else
for CONFIG in /etc/unicorn/*.conf; do
# clean variables from prev configs
unset APP_USER
unset RAILS_ROOT
unset RAILS_ENV
unset UNICORN
unset UNICORN_CONFIG

# import the variables
. $CONFIG
setup $CONFIG
if [ $? -eq 1 ]; then
continue
fi
# run the start/stop/etc command
cmd $1
done
fi

Y lo haces ejecutable del siguiente modo:

# chmod a+rx /etc/init.d/unicorn

Ahora crea el fichero /etc/unicorn/unicorn.conf con el siguiente contenido:

RAILS_ENV=production
RAILS_ROOT=/var/ror/app/current
UNICORN="/usr/share/rvm/gems/ruby-2.1.3/bin/unicorn" #see rvm wrapper above
APP_USER="ror"
UNICORN_CONFIG="/var/ror/unicorn/config/unicorn.rb"

Por último, activa unicorn en cada inicio:

# update-rc.d unicorn defaults
# update-rc.d unicorn enable

Instalación y configuración de NGINX en Ubuntu 16.04

En primer lugar, instala Nginx:

# apt install nginx

Edita el fichero /etc/nginx/nginx.conf y añade lo siguiente a la sección HTTP:

upstream rails {
# Path to Unicorn socket file
server unix:/var/run/unicorn/unicorn.sock fail_timeout=0;
}

Después, elimina el fichero de configuración de vhost por defecto:

#  rm /etc/nginx/sites-enabled/default

Y crea uno nuevo llamado midominio.com con el siguiente contenido:

server {
listen 80 default;
server_name midominio.com;

root /var/ror/app/current;

try_files $uri/index.html $uri @rails;

location @rails {
proxy_pass http://rails;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header Host $http_host;
proxy_redirect off;
}

error_page 500 502 503 504 /500.html;
client_max_body_size 4G;
keepalive_timeout 10;
}

A continuación, activa el site y reinicia Nginx:

# ln -s /etc/nginx/sites-available/midominio.com /etc/nginx/sites-enabled
# service nginx restart

Configuración de logrotate

Crea el fichero /etc/logrotate.d/unicorn con el siguiente contenido:

/var/log/unicorn/*.log {
daily
missingok
rotate 14
compress
dateext
delaycompress
notifempty
copytruncate
create 0666 ror rvm
maxage 14
}

Opcionalmente, puedes instalar una app de demo para comprobar que todo funciona correctamente. Te explicamos cómo hacerlo.

Instalación de app de demo

Accede con el usuario ror y ejecuta los siguientes comandos:

$ cd /var/ror/app
$ rails new current
$ cd current
$ rails generate scaffold Task title:string note:text
$ RAILS_ENV=production  rake db:migrate

Después, arranca unicorn como usuario root:

# /etc/init.d/unicorn start

Finalmente, comprueba que funciona todo correctamente accediendo a la URL:
http://ip.de.vm/public
Y ya está, ahora ya puedes desplegar tu aplicación en la carpeta /var/ror/app/current

Para comentar sobre este artículo, rellena el formulario. Los campos marcados con un asterisco (*) son obligatorios.


*