Si estás interasado en asistir, apúntate rápidamente, ya que creo que las plazas van a volar. El calendario de ponencias promete bastante. La keynote de apertura estará a cargo de Yukihiro Matsumoto, el creador de Ruby.

El script se invoca de la siguiente manera:

$ renamepics.rb new_name [n_digits]

y lo que hace es renombrar cada fichero JPG del directorio actual, de manera que el nuevo nombre será de la forma:

new_name_ddd.jpg

Siendo ddd un número de n_digits dígitos, y siendo la númeración de las fotografías consecutiva. Es decir, si tengo, por ejemplo, estos 3 ficheros:

IMG_4367.jpg
IMG_4370.jpg
IMG_4389.jpg

Ejecutando:

$ renamepics.rb Fuerteventura 2

Se convertirían en:

Fuerteventura_01.jpg
Fuerteventura_02.jpg
Fuerteventura_03.jpg

Maníatico que es uno. Si alguien lo usa, que sea bajo su propia responsabilidad. Aquí tenéis el script:

#!/usr/local/bin/ruby
unless (1..2).include? ARGV.length 
  puts "Usage: #{$0} new_name [n_digits]"
  exit
end
 
require 'fileutils'
 
new_name = ARGV[0]
n_digits = ARGV[1].nil? ? 3 : ARGV[1]
 
c = 1
d = Dir.new(Dir.pwd)
d.entries.sort.each do |e|
  re = /(.+).jpg/
  md = re.match e
  unless md.nil?
    n = new_name + '_' + sprintf("%0#{n_digits}d", c) + ".jpg"
    c = c + 1
    begin
      FileUtils.mv "#{e}", "#{n}"
    rescue Exception => e
      md = /^same file/.match e
      next unless md.nil?
    end
    puts "#{e} => #{n}"
  end
end

La canción del video es “Eterno domingo”, del grupo Los Sundayers. Uno de los miembros del grupo asistió a la Conferencia Rails y repartió copias de su disco, también llamado “Eterno domingo”. Da gusto ver que hay grupos que se animan a publicar sus obras con licencias Creative Commons.

La primera edición fue la del 2006, la del descubrimiento. Para los que ya sabíamos lo que se puede disfrutar programando en Rails, fue el descubrimiento de que había mucha otra gente programando con este framework tan poco conocido por entonces. Para los que se acercaban por primera vez a Rails, fue el descubrimiento del framework en sí. Fue todo un éxito porque no sabíamos si seríamos más de 20 y acabamos siendo unos 150.

La segunda edición, la del 2007, fue la de la consolidación. Sabíamos de antemano que el interés por Rails existía y aquí vimos que dicho interés era creciente, que las empresas estaban adoptando la tecnología y que el framework maduraba.

¿Cómo será la próxima edición? Por lo pronto, hay un gran interés por patrocionar el evento, con lo que veo que el negocio en torno a Rails está creciendo. Por otro lado, parece que va a ser posible traer a varios gurús a nivel mundial. Este año también se reducirá el número de ponencias, para así ofrecer las de mayor calidad.

Por cierto, ¿todavía no has presentado tu propuesta de ponencia? El plazo termina el 29 de septiembre. No lo dejes para el último día.

• Vulnerabilidad por denegación de servicio en la librería REXML.
• Qué nos espera en Ruby 1.9.
• daemon_controller: una librería para gestionar demonios.
• Rails 2.2 será “thread safe”.
• Ventajas en incovenientes de GitHub y RubyForge como repositorios de gemas.

• Se anuncia Rails Summit Latin America 2008.
• Engine Yard consigue $15 millones de financiación.
• Se publica libxml-ruby 0.8.0, con una gran mejora del rendimiento en el parseo de XML.
• Se lanza JRuby 1.1.3.
• Open Flash Chart ahora como plugin para Rails.
• Se lanza RedCloth 4.0.
• Disponible el calendario de la RailsConf Europe 2008.
• La internacionalización llega a Rails Edge.

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-date loading 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.

Tutorial completo

• Rails en producción - Parte 1 - Introducción
• Rails en producción - Parte 2 - Configuración del servidor debian
• Rails en producción - Parte 3 - MySQL, Ruby y Rails
• Rails en producción - Parte 4 - Servidor web nginx
• Rails en producción - Parte 5 - Mongrels e instalación de nuestra aplicación
• Rails en producción - Parte 6 - Cluster de mongrels

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

Instalación de nuestra aplicación

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

Tutorial completo

• Rails en producción - Parte 1 - Introducción
• Rails en producción - Parte 2 - Configuración del servidor debian
• Rails en producción - Parte 3 - MySQL, Ruby y Rails
• Rails en producción - Parte 4 - Servidor web nginx
• Rails en producción - Parte 5 - Mongrels e instalación de nuestra aplicación
• Rails en producción - Parte 6 - Cluster de mongrels

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

Tutorial completo

• Rails en producción - Parte 1 - Introducción
• Rails en producción - Parte 2 - Configuración del servidor debian
• Rails en producción - Parte 3 - MySQL, Ruby y Rails
• Rails en producción - Parte 4 - Servidor web nginx
• Rails en producción - Parte 5 - Mongrels e instalación de nuestra aplicación
• Rails en producción - Parte 6 - Cluster de mongrels

Para que la instalación de MySQL no nos instale exim, instalaremos el servidor de correo Postfix.

$ sudo aptitude install postfix -y

MySQL

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

Ruby

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

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.

Rails

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

RMagick

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

Tutorial completo

• Rails en producción - Parte 1 - Introducción
• Rails en producción - Parte 2 - Configuración del servidor debian
• Rails en producción - Parte 3 - MySQL, Ruby y Rails
• Rails en producción - Parte 4 - Servidor web nginx
• Rails en producción - Parte 5 - Mongrels e instalación de nuestra aplicación
• Rails en producción - Parte 6 - Cluster de mongrels