Noticias destacadas de Ruby y Rails durante el mes de julio de 2008:
Ya sólo nos queda configurar un cluster de mongrels y apuntar hacia ellos el servidor web nginx. Supongamos que vamos a arrancar 4 mongrels, tal y como representamos en la figura de la primera parte parte de este tutorial. Los mongrels escucharán en los puertos 8000 a 8003.
Para configurar el cluster hacemos:
$ mongrel_rails cluster::configure -e production -p 8000 -N 4 -c /var/miaplicacion/current -a 127.0.0.1 ** Ruby version is not up-to-dateloading cgi_multipart_eof_fix Writing configuration file to config/mongrel_cluster.yml.
Este comando habrá creado el fichero config/mongrel_cluster.yml. Lo editamos y añadimos al final sendas líneas indicando el usuario y el grupo que ejecutarán los mongrels. Como ya indicamos, será un usuario no privilegiado el que ejecute tanto el servidor web como los mongrels:
cwd: /var/www/miaplicacion/current log_file: log/mongrel.log port: "8000" environment: production address: 127.0.0.1 pid_file: tmp/pids/mongrel.pid servers: 4 user: usuario group: usuario
Añadiremos el cluster de mongrels al arranque de la máquina:
sudo mkdir /etc/mongrel_cluster sudo ln -s /var/www/miaplicacion/current/config/mongrel_cluster.yml /etc/mongrel_cluster/miaplicacion.yml sudo cp /usr/lib/ruby/gems/1.8/gems/mongrel_cluster-1.0.5/resources/mongrel_cluster /etc/init.d sudo chmod +x /etc/init.d/mongrel_cluster sudo /usr/sbin/update-rc.d -f mongrel_cluster defaults sudo ln -s /usr/bin/ruby1.8 /usr/bin/ruby
Y ya podremos arrancar y parar el cluster de mongrels:
$ sudo /etc/init.d/mongrel_cluster start $ sudo /etc/init.d/mongrel_cluster stop
Ahora sólo nos queda apuntar el servidor web nginx a los mongrels. Para ello, editaremos el fichero /usr/local/nginx/conf/nginx.conf. Éste es un ejemplo básico del cual podemos partir.
user miusuario miusuario; worker_processes 4; events { worker_connections 1024; } http { include mime.types; default_type application/octet-stream; sendfile on; keepalive_timeout 65; gzip on; upstream miaplicacion { server 127.0.0.1:8000; server 127.0.0.1:8001; server 127.0.0.1:8002; server 127.0.0.1:8003; } server { listen 80; server_name midominio.com; root /var/www/miaplicacion/current/public; index index.html; location / { proxy_set_header X-Real-IP $remote_addr; proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; proxy_set_header Host $http_host; proxy_redirect false; if (-f $request_filename/index.html) { rewrite (.*) $1/index.html break; } if (-f $request_filename.html) { rewrite (.*) $1.html break; } if (!-f $request_filename) { proxy_pass http://miaplicacion; break; } } # redirect server error pages to the static page /50x.html # error_page 500 502 503 504 /50x.html; location = /50x.html { root html; } } }
En la sección “upstream” apuntamos hacia los mongrels. En ella, “miaplicacion” es una etiqueta, la misma que usamos más abajo en la línea:
proxy_pass http://miaplicacion;En la sección “server” cabe destacar que “root” apunta al directorio public de mi aplicación.
Rearrancamos nginx para que la nueva configuración surta efecto:
$ sudo /etc/init.d/nginx stop $ sudo /etc/init.d/nginx start
Y ahora sí, por fin, tenemos que poder abrir desde nuestro navegador la URL:
http://midominio.com/
y acceder a nuestra aplicación. Si no tenemos configurado todavía la entrada en DNS, tendremos que poner la IP.
Como una última prueba, probaremos una vez más a rearracar la máquina y ver que todo arranca correctamente.
Mongrel será el encargado de atender las peticiones HTTP que lleguen del servidor web y ejecutar nuestra aplicación en el intérprete de Ruby.
Para instalar mongrel simplemente haremos:
$ sudo gem install mongrel mongrel_cluster --include-dependencies --no-rdoc --no-ri
Supondré que tenemos nuestra aplicación en un repositorio de subversion. En este caso, antes de poder hacer un export de la aplicación desde el repositorio, necesitaré instalar subversion:
$ sudo aptitude install subversion -y
Ahora ya podré transferir una copia de mi aplicación al servidor de producción. Supondré que la aplicación la vamos a instalar, por ejemplo, en /var/www/miaplicacion/current.
$ sudo chown usuario:usuario /var/www $ mkdir /var/www/miaplicacion $ cd /var/www/miaplicacion $ svn export http://svn.midominio.com/miaplicacion/trunk current
Necesitamos crear una base de datos para la aplicación:
$ mysql --user=root -p mysql> grant all on miaplicacion_production.* to miaplicacion@localhost identified by 'miaplicacion'; mysql> flush privileges; mysql> create database miaplicacion_production;
Es decir, hemos creado una base de datos llamada “miaplicacion_production” y un usuario “miaplicacion”, con idéntica password, que dispone de todos los permisos en “miaplicacion_production”.
Normalmente, tendremos que configurar el fichero config/database.yml de nuestra aplicación para que apunte a la base de datos que acabamos de crear:
production: adapter: mysql database: miaplicacion_production username: miaplicacion password: miaplicacion socket: /var/run/mysqld/mysqld.sock host: localhost encoding: utf8
Antes de poder arrancar nuestra aplicación deberemos instalar todas las gemas que utilicemos y que no hayamos instalado. Si no nos acordamos podemos intentar arrancar la aplicación y ver los errores. Leyendo el log de errores suele ser fácil identificar si nos falta alguna gema. Una que siempre viene bien será:
$ sudo gem install rake
Hay que tener en cuenta que si no especificamos la versión, gem install instalará la última versión disponible en el repositorio. Esto quiere decir que en el entorno de desarrollo y en el de test, si instalamos las gemas hace tiempo, las versiones pueden ser inferiores, y por lo tanto, nos podemos encontrar con problemas de compatibilidad. Para ver las gemas instaladas en una máquina y sus versiones podemos ejecutar:
$ gem list
Ahora ya puedo arrancar mi aplicación. De momento, para probar, arrancaremos un único proceso mongrel. Todavía no hemos configurado el servidor web para que apunte a los mongrels, así que no podremos comprobar con un navegador que funciona. Simplemente, veremos que arranca correctamente leyendo el fichero log/production.log:
$ cd /var/www/miaplicacion/current $ mongrel_rails start -d -e production -p 8000 -P log/mongrel8000.pid
Si en el fichero de log vemos que la aplicación ha arrancado, podríamos incluso comprobar que sirve peticiones:
$ cd $ wget http://localhost:8000/
Esto me guardaría en el directorio raíz del usuario un fichero llamado index.html con el HTML de la página raíz de mi aplicación. En el fichero de log debería poder ver la petición. ¿Quién necesita un browser?
En el último capítulo configuraremos un cluster de mongrels y apuntaremos el servidor web hacia ellos. Por eso, ahora, paramos el mongrel que hemos arrancado como prueba:
$ mongrel_rails stop -P log/mongrel8000.pid
El servidor web que vamos a utilizar es nginx. Lo instalaremos compilando el código fuente de la última versión estable. Yo he utilizado la versión 0.6.32.
Primeramente, instalaremos varios paquetes de debian que son necesarios:
$ sudo aptitude install libpcre3 libpcre3-dev libpcrecpp0 libssl-dev zlib1g-dev
En el directorio sources que creamos anteriormente para compilar Rubygems, nos descargamos nginx y hacemos el configure con la opción with-http_ssl_module:
$ sudo aptitude install libpcre3 libpcre3-dev libpcrecpp0 libssl-dev zlib1g-dev $ cd ~/sources $ wget http://sysoev.ru/nginx/nginx-0.6.32.tar.gz $ tar xvf nginx-0.6.32.tar.gz $ cd nginx-0.6.32 $ ./configure --with-http_ssl_module
La salida del configure es muy extensa. Al final nos aparecerá un resumen con el path de los ejecutables y los ficheros de configuración:
Configuration summary + using system PCRE library + OpenSSL library is not used + md5 library is not used + sha1 library is not used + using system zlib library nginx path prefix: "/usr/local/nginx" nginx binary file: "/usr/local/nginx/sbin/nginx" nginx configuration prefix: "/usr/local/nginx/conf" nginx configuration file: "/usr/local/nginx/conf/nginx.conf" nginx pid file: "/usr/local/nginx/logs/nginx.pid" nginx error log file: "/usr/local/nginx/logs/error.log" nginx http access log file: "/usr/local/nginx/logs/access.log" nginx http client request body temporary files: "/usr/local/nginx/client_body_temp" nginx http proxy temporary files: "/usr/local/nginx/proxy_temp" nginx http fastcgi temporary files: "/usr/local/nginx/fastcgi_temp"
Después del configure, ejecutamos make para compilar y make install para instalar:
$ make $ sudo make install
Para probar que funciona arrancamos el demonio:
$ sudo /usr/local/nginx/sbin/nginx
Esto habrá arrancado el servidor web en el puerto 80. En un navegador podemos teclear la URL:
http://IP/
Siendo IP, claro está, la IP de nuestro servidor. Nos deberá aparecer la página de bienvenida a nginx.
Paramos el proceso que hemos arrancado:
$ sudo kill `cat /usr/local/nginx/logs/nginx.pid`
Creamos el fichero de arranque de nginx /etc/init.d/nginx con el siguiente contenido:
#! /bin/sh ### BEGIN INIT INFO # Provides: nginx # Required-Start: $all # Required-Stop: $all # Default-Start: 2 3 4 5 # Default-Stop: 0 1 6 # Short-Description: starts the nginx web server # Description: starts nginx using start-stop-daemon ### END INIT INFO PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin DAEMON=/usr/local/nginx/sbin/nginx NAME=nginx DESC=nginx test -x $DAEMON || exit 0 # Include nginx defaults if available if [ -f /etc/default/nginx ] ; then . /etc/default/nginx fi set -e case "$1" in start) echo -n "Starting $DESC: " start-stop-daemon --start --quiet --pidfile /usr/local/nginx/logs/nginx.pid \ --exec $DAEMON -- $DAEMON_OPTS echo "$NAME." ;; stop) echo -n "Stopping $DESC: " start-stop-daemon --stop --quiet --pidfile /usr/local/nginx/logs/nginx.pid \ --exec $DAEMON echo "$NAME." ;; restart|force-reload) echo -n "Restarting $DESC: " start-stop-daemon --stop --quiet --pidfile \ /usr/local/nginx/logs/nginx.pid --exec $DAEMON sleep 1 start-stop-daemon --start --quiet --pidfile \ /usr/local/nginx/logs/nginx.pid --exec $DAEMON -- $DAEMON_OPTS echo "$NAME." ;; reload) echo -n "Reloading $DESC configuration: " start-stop-daemon --stop --signal HUP --quiet --pidfile /usr/local/nginx/logs/nginx.pid \ --exec $DAEMON echo "$NAME." ;; *) N=/etc/init.d/$NAME echo "Usage: $N {start|stop|restart|force-reload}" >&2 exit 1 ;; esac exit 0
Le damos permisos de ejecución y lo añadimos al arranque de la máquina:
$ sudo chmod +x /etc/init.d/nginx $ sudo /usr/sbin/update-rc.d -f nginx defaults
Editamos el fichero de configuración /usr/local/nginx/conf/nginx.conf. El usuario encargado de ejecutar nginx será el usuario no privilegiado que hemos creado anteriomente. También podemos ajustar el número de procesos que atenderán peticiones:
user usuario usuario;
worker_processes 4;Para arrancarlo y pararlo ya podemos hacer:
$ sudo /etc/init.d/nginx start $ sudo /etc/init.d/nginx stop
Para que la instalación de MySQL no nos instale exim, instalaremos el servidor de correo Postfix.
$ sudo aptitude install postfix -y
Instalamos los paquetes de MySQL. Esto además nos creará el usuario mysql en nuestro sistema:
$ sudo aptitude install mysql-server mysql-client libmysqlclient15-dev libmysql-ruby -y
Configuraremos una contraseña para el usuario root de la base de datos:
$ mysqladmin -u root password mipassword
La versión de Ruby paquetizada en debian 4.0 es la 1.8.5. Si quisiéramos una versión superior, deberíamos compilar Ruby desde el código fuente.
Nosotros instalaremos los paquetes disponibles para debian. Para ello:
$ sudo aptitude install ruby1.8-dev ruby1.8 ri1.8 rdoc1.8 irb1.8 libreadline-ruby1.8 libruby1.8 libopenssl-ruby -y
A continuación crearemos los siguientes enlaces:
$ sudo ln -s /usr/bin/ruby1.8 /usr/local/bin/ruby $ sudo ln -s /usr/bin/ri1.8 /usr/local/bin/ri $ sudo ln -s /usr/bin/rdoc1.8 /usr/local/bin/rdoc $ sudo ln -s /usr/bin/irb1.8 /usr/local/bin/irb $ sudo ln -s /usr/bin/gem /usr/local/bin/gem
Rubygems es la herramienta para gestionar librerías y programas Ruby en forma de paquetes. Instalaremos Rubygems compilando el código fuente. Para ello, nos crearemos, en el directorio raíz de nuestro usuario, un directorio llamado sources. En él haremos:
$ mkdir sources $ cd sources $ wget http://rubyforge.org/frs/download.php/38646/rubygems-1.2.0.tgz $ tar xzvf rubygems-1.2.0.tgz $ cd rubygems-1.2.0 $ sudo ruby setup.rb $ sudo ln -s /usr/bin/gem1.8 /usr/bin/gem $ sudo gem update $ sudo gem update --system $ gem -v 1.2.0
Con esto habremos instalado la versión 1.2 de Rubygems. Comprueba cuál es la última versión estable cuando sigas estas instrucciones.
En teoría, si hemos congelado Rails en el directorio vendor de nuestra aplicación, no es necesario disponer de una instalación de Rails global en la máquina. A pesar de ello, si quisiéramos instalar Rails:
$ sudo gem install rails --include-dependencies --no-rdoc -no-ri
Esto me instalaría la gema rails y las gemas de las que depende. Como veis, gracias a que Rails está paquetizado en gemas, el proceso de instalación es muy sencillo.
Si hemos congelado en vendor Rails 1.2, no tendremos todas las gemas necesarias. En este caso deberíamos al menos instalar la gema actionwebservice y las que dependen de ella:
$ sudo gem install actionwebservice --include-dependencies --no-rdoc -no-ri
Una librería Ruby que es frecuente utilizar es RMagick. Para que funcione, deberemos instalar ImageMagick en nuestro sistema:
$ sudo aptitude install imagemagick librmagick-ruby1.8 librmagick-ruby-doc libfreetype6-dev xml-core -y
Y para comprobar que funciona correctamente:
$ irb irb(main):001:0> require 'RMagick' => true
![[Valid RSS]](/wp-content/themes/javiervidal/images/valid-rss.png "Validate my RSS feed")