Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
- Loading branch information
Showing
4 changed files
with
696 additions
and
1 deletion.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,246 @@ | ||
| <p>Como desarrolladores Rails con frecuencia nos encontraremos con que nuestro entorno de desarrollo es muy distinto del entorno de producción. De hecho no es nada raro tener que desarrollar la aplicación en un sistema operativo distinto del que se ejecutará en producción. Por otro lado, las aplicaciones Rails suelen tener también muchas dependencias que pueden ser difíciles de replicar en varias máquinas diferentes. | ||
|
|
||
| <p><a href="http://vagrantup.com/">Vagrant</a> nos puede ser útil para solventar este problema. Permite configurar y manipular entornos de máquinas virtuales por lo que podemos configurar una pequeña distribución linux dentro nuestro sistema operativo para ejecutar en ella nuestra aplicación junto con todas sus dependencias, pudiéndose empaquetar todo de manera portable para poder compartirlo con otros.</p> | ||
|
|
||
| <p>Probar Vagrant resultará muy útil para todos los programadores Rails ya que da una idea precisa sobre cómo configurar un entorno de producción para las aplicaciones, y también resulta útil para configurar entornos de preproducción | ||
|
|
||
| <h3>Instalación de Virtual Box y Vagrant</h3> | ||
|
|
||
| <p>Vagrant utiliza <a href="https://www.virtualbox.org/">VirtualBox</a> de Oracle, por lo que tendremos que instalarlo en nuestra máquina si todavía no lo hemos hecho. VirtualBox está disponible para Windows, OS X y Linux, por lo que deberíamos poder encontrar una versión instalable en nuestro sistema operativo. Una vez que tengamos VirtualBox podemos instalar Vagrant, que es una gema de Ruby que se instala ejecutando la siguiente orden:</p> | ||
|
|
||
| ``` terminal | ||
| $ gem install vagrant | ||
| ``` | ||
|
|
||
| <h3>Creación de una máquina</h3> | ||
|
|
||
| <p>El siguiente paso es crear una máquina virtual, lo que Vagrant denomina una <em>caja</em>. Hay una lista de máquinas disponibles en <a href="http://www.vagrantbox.es/">Vagrantbox.es</a>, de donde se pueden descargar. Usaremos <a href="http://www.vagrantbox.es/1/">Ubuntu lucid 32</a>, que está basada en Ubuntu Linux 10.04. Para instalar la caja tan sólo tenemos que lanzar <code>vagrant box add</code> pasandole el nombre y la URL de la máquina.</p> | ||
|
|
||
| ``` terminal | ||
| $ vagrant box add lucid32 http://files.vagrantup.com/lucid32.box | ||
| [vagrant] Downloading with Vagrant::Downloaders::HTTP... | ||
| [vagrant] Downloading box: http://files.vagrantup.com/lucid32.box | ||
| [vagrant] Extracting box... | ||
| [vagrant] Verifying box... | ||
| [vagrant] Cleaning up downloaded box... | ||
| ``` | ||
|
|
||
| <p>Las cajas pueden ser bastante grandes (del orden de varios cientos de megabytes) por lo que la descarga puede tardar un rato. Si ya tenemos la caja descargada podemos pasar una URL de archivo para instalar desde el sistema de archivos local.</p> | ||
|
|
||
| <p>Tras la descarga de la caja y su instalación podemos empezar a usarla para configurar nuestro entorno virtual. En Vagrant esto se hace por lo general para un proyecto específico, así que crearemos un nuevo proyecto con el que trabajar, y luego nos cambiaremos a su directorio.</p> | ||
|
|
||
| ``` terminal | ||
| $ rails new todo | ||
| $ cd todo | ||
| ``` | ||
|
|
||
| <p>Podemos crear una máquina virtual para esta aplicación y sus dependencias ejecutando <code>vagrant init</code> y pasando el nombre de la caja que queremos utilizar.</p> | ||
|
|
||
| ``` terminal | ||
| $ vagrant init lucid32 | ||
| create Vagrantfile | ||
| ``` | ||
|
|
||
| <p>Lo que hace esta orden es crear un archivo llamado <code>Vagrantfile</code>. El fichero contiene la información sobre la configuración de la caja Vagrant vinculada a esta aplicación y por defecto toda esta información viene comentada salvo la línea que especifica la caja a utilizar.</p> | ||
|
|
||
| ``` /Vagrantfile | ||
| Vagrant::Config.run do |config| | ||
| # All Vagrant configuration is done here. The most common configuration | ||
| # options are documented and commented below. For a complete reference, | ||
| # please see the online documentation at vagrantup.com. | ||
|
|
||
| # Every Vagrant virtual environment requires a box to build off of. | ||
| config.vm.box = "lucid32" | ||
|
|
||
| # Rest of file omitted. | ||
| end | ||
| ``` | ||
|
|
||
| <p>Hay otras muchas opciones de configuración disponibles y merece la pena dedicar un minuto para estudiarlas.</p> | ||
|
|
||
| <h3>Inicio de la máquina virtual de Vagrant</h3> | ||
|
|
||
| <p>Es hora de que comience la magia. Lanzando <code>vagrant up</code> comenzará el arranque de nuestra máquina virtual, lo que puede llevar varios minutos pero una vez que hayamos terminado podemos hacer SSH en ella con</p> | ||
|
|
||
| ``` terminal | ||
| $ vagrant ssh | ||
| ``` | ||
|
|
||
| <p>Ya estamos dentro de nuestra máquina Virtual con Ubuntu. Se trata de una configuración con muy pocos paquetes instalados pero hay un par de cosas que merece la pena destacar. La primera es que existe el usuario <code>vagrant</code> (que es con el que hemos iniciado la sesión), y el otro es que tenemos privilegios de <code>sudo</code> sin necesidad de clave, lo cual está bien para nuestro entorno de desarrollo. Vagrant también deja configurado un directorio compartido en <code>/vagrant</code> que apunta al directorio donde tenemos nuestra aplicación Rails.</p> | ||
|
|
||
| <h3>Instalación de las dependencias de nuestra aplicación</h3> | ||
|
|
||
| <p>El objetivo es poner en marca nuestra aplicación Rails dentro de la máquina virtual, por lo que tendremos que cargar sus dependencias. Primero tenemos que instalar Ruby y Sqlite. La máquina virtual viene con Ruby 1.8.7, por lo que puede ejecutar <a href="http://wiki.opscode.com/display/chef/Home">Recetas de Chef</a>.</p> | ||
|
|
||
| <p>Chef permite automatizar la configuración de los servidores. Para instalar Ruby 1.9 y Sqlite podríamos aplicar las recetas necesarias y Chef las instalará por nosotros. Chef se integra muy bien con Vagrant pero es un tema aparte que veremos en un episodio futuro, así que vamos a configurar nuestro servidor sin usar Chef con lo que tendremos una mejor idea de cómo encajan todas las piezas.</p> | ||
|
|
||
| <p>Primero usaremos <code>apt-get</code> para garantizar que el software instalado está al día.</p> | ||
|
|
||
| ``` terminal | ||
| $ sudo apt-get update | ||
| ``` | ||
|
|
||
| <p>Tras esto, instalaremos el software que nos hace falta: lo esencial para compilar software, Zlib, Git y Sqlite3.</p> | ||
|
|
||
|
|
||
| ``` terminal | ||
| $ sudo apt-get install build-essential zlib1g-dev git-core sqlite3 libsqlite3-dev | ||
| ``` | ||
|
|
||
| <p>Lo último que nos queda por instalar es Ruby 1.9. Podríamos instalarlo de cero o utilizando RVM pero vamos a usar una nueva herramienta llamada <a href="http://github.com/sstephenson/rbenv">rbenv</a>. Una ventaja de Vagrant es que podemos experimentar en un entorno seguro con herramientas que no hayamos usado antes, y si se rompe algo siempre podemos borrar la máquina virtual y empezar de cero.</p> | ||
|
|
||
| <p>Para instalar rbenv en nuestra máquina virtual tan sólo tenemos que lanzar las órdenes que se mencionan en la sección 2.1 del <a href="https://github.com/sstephenson/rbenv/blob/master/README.md">README</a>. Primero clonaremos el repostorio en <code>~/.rbenv</code>.</p> | ||
|
|
||
| ``` terminal | ||
| $ cd | ||
| $ git clone git://github.com/sstephenson/rbenv.git .rbenv | ||
| ``` | ||
| <p>A continuación añadiremos el directorio <code>bin</code> de rbenv en nuestro PATH y lo ejecutaremos con la opción <codE>init</codE> en nuestro perfil de Bash.</p> | ||
|
|
||
|
|
||
| ``` terminal | ||
| $ echo 'export PATH="$HOME/.rbenv/bin:$PATH"' >> ~/.bash_profile | ||
| $ echo 'eval "$(rbenv init -)"' >> ~/.bash_profile | ||
| ``` | ||
| <p>Tendremos que volver a cargar el perfil de bash para que los cambios surtan efecto.</p> | ||
|
|
||
| ``` terminal | ||
| $ source .bash_profile | ||
| ``` | ||
| <p>Ya tenemos disponible la orden <code>rbenv</code>, que podemos utilizar para gestionar nuestras versiones de Ruby, pero todavía no podemos instalar Ruby. Utilizaremos <a href="https://github.com/sstephenson/ruby-build">Ruby Build</a> para ello, tan sólo tenemos que clonar su repositorio Git y una vez dentro del directorio ejecutar su <em>script</em> de instalación.</p> | ||
|
|
||
| ``` terminal | ||
| $ git clone https://github.com/sstephenson/ruby-build.git | ||
| $ cd ruby-build | ||
| $ sudo ./install.sh | ||
| ``` | ||
| <p>Podemos usar rbenv para instalar la versión actual de Ruby, la 1.9.2</p> | ||
|
|
||
|
|
||
| ``` terminal | ||
| $ rbenv install 1.9.2-p290 | ||
| ``` | ||
| <p>Tras esto habremos compilado Ruby 1.9.2. Tenemos que ejecutar <code>rbenv rehash</code> cada vez que cambiemos los binarios y luego tenemos que ejecutar la siguiente orden para que 1.9.2 sea la versión global por defecto de Ruby en nuestra máquina virtual.</p> | ||
|
|
||
|
|
||
| ``` terminal | ||
| $ rbenv global 1.9.2-p290 | ||
| ``` | ||
| <p>Cuando comprobemos la versión de Ruby, veremos que es la 1.9.2, tal y como queríamos.</p> | ||
|
|
||
|
|
||
| ``` terminal | ||
| $ ruby -v | ||
| ruby 1.9.2p290 (2011-07-09 revision 32553) [i686-linux] | ||
| ``` | ||
| <h3>Instalación de nuestra aplicación Rails</h3> | ||
|
|
||
| <p>Una vez que tenemos la versión correcta de Ruby, podemos empezar a trabajar en levantar la aplicación Rails. Si cambiamos al directorio compartido de nuestra aplicación y ejecutamos <code>bundle</code> para cargar sus dependencias nos toparemos con un problema.</p> | ||
|
|
||
| ``` terminal | ||
| vagrant@lucid32:~$ cd /vagrant/ | ||
| vagrant@lucid32:/vagrant$ bundle | ||
| bundle: command not found | ||
| ``` | ||
| <p>Para corregir este problema sólo tenemos que instalar la gema Bundler</p> | ||
|
|
||
|
|
||
| ``` terminal | ||
| $ gem install bundler | ||
| ``` | ||
|
|
||
| <p>Una vez que se haya instalado la gema tan sólo tenemos que ejecutar <code>rbenv rehash</code> para que esté disponible el ejecutable <code>bundle</code>. Ya podemos ejecutar <code>bundle </code> para instalar las gemas de nuestra aplicación.</p> | ||
|
|
||
| <p>Si intentamos lanzar la aplicación ahora devolverá un error quejándose de que no puede encontrar un entorno de ejecución JavaScript. Tiene sentido, porque Rails 3.1 requiere que exista un entorno de JavaScript, y Ubuntu no viene con uno por defecto. La solución rápida es añadir una gema llamada <a href="https://github.com/cowboyd/therubyracer">therubyracer</a> a nuestro Gemfile y ejecutar <code>bundle</code> dentro de la máquina virtual. Con esto se instalará el motor JavaScript V8.</p> | ||
|
|
||
|
|
||
| ``` /Gemfile | ||
| gem 'therubyracer' | ||
| ``` | ||
| <p>Tras la instalación de esta gema podemos intentar lanzar el servidor otra vez.</p> | ||
|
|
||
|
|
||
| ``` terminal | ||
| $ bundle exec rails s | ||
| ``` | ||
|
|
||
| <p>Esta vez arranca correctamente y nuestra aplicación se carga en el puerto 3000. No podemos verla en el navegador, porque está en ejecución dentro de la máquina virtual. Tenemos que decirle a Vagrant que redirija el puerto a nuestra máquina, lo que podemos hacer modificando el <code>Vagrantfile</code>. Tenemos que descomentar la siguiente línea, ponerle un nombre más adecuado y decirle que dirija el puerto 3000 al mismo puerto en nuestra máquina local.</p> | ||
|
|
||
|
|
||
| ``` /Vagrantfile | ||
| config.vm.forward_port "rails", 3000, 3000 | ||
| ``` | ||
|
|
||
| <p>Tras este cambio de configuración tenemos que salir de nuestra sesión en Vagrant ejecutando <code>exit</code> dentro de la máquina virtual y luego volviendo a cargarla con <code>vagrant reload</code>. Esto parará la máquina virtual y la recargará a continuación. Tras esto podemos volver a hacer SSH.</p> | ||
|
|
||
| ``` terminal | ||
| $ vagrant ssh | ||
|
|
||
| ``` | ||
|
|
||
| <p>Ya en la máquina virtual podemos cambiarnos al directorio de nuestra aplicación y lanzar nuevamente el servidor.</p> | ||
|
|
||
|
|
||
| ``` terminal | ||
| vagrant@lucid32:~$ cd /vagrant | ||
| vagrant@lucid32:/vagrant$ bundle exec rails s | ||
| ``` | ||
|
|
||
| <p>Con esto arranca otra vez el servidor pero ya está accesible desde nuestra máquina.</p> | ||
|
|
||
|
|
||
| <div class="imageWrapper"> | ||
| <img src="http://asciicasts.com/system/photos/794/original/E292I01.png" width="829" height="361" alt="La aplicación ejecutándose en Vagrant."/> | ||
| </div> | ||
|
|
||
| <p>Como la aplicación Rails está compartida con Vagrant, cualquier cambio que hagamos en el directorio de nuestro ordenador se verá reflejado en la máquina virtual. Si modificamos la página en <code>/public/index.html</code> y recargamos el navegador, veremos los cambios inmediatamente.</p> | ||
|
|
||
|
|
||
| ```/public/index.html | ||
| <h2>You’re riding Ruby on Rails on Vagrant!</h2> | ||
| ``` | ||
| <div class="imageWrapper"> | ||
| <img src="http://asciicasts.com/system/photos/795/original/E292I02.png" width="829" height="361" alt="Los cambios se ven reflejados inmediatamente."/> | ||
| </div> | ||
|
|
||
| <h3>Otras posibilidades de Vagrant</h3> | ||
|
|
||
| <p>Vagrant proporciona varias órdenes para gestionar la máquina virtual. Por ejemplo, para ver el estado actual podemos lanzar <code>vagrant status</code>.</p> | ||
|
|
||
| ``` terminal | ||
| $ vagrant status | ||
| Current VM states: | ||
|
|
||
| default running | ||
|
|
||
| The VM is running. To stop this VM, you can run `vagrant halt` to | ||
| shut it down forcefully, or you can run `vagrant suspend` to simply | ||
| suspend the virtual machine. In either case, to restart it again, | ||
| simply run `vagrant up`. | ||
| ``` | ||
|
|
||
| <p>Para parar temporalmente la máquina y luego reiniciarla podemos usar las órdenes <code>suspend</code> y <code>resume</code>.</p> | ||
|
|
||
|
|
||
| ``` terminal | ||
| $ vagrant suspend | ||
| [default] Saving VM state and suspending execution... | ||
|
|
||
| $ vagrant resume | ||
| [default] Resuming suspended VM... | ||
| [default] Booting VM... | ||
| [default] Waiting for VM to boot. This can take a few minutes. | ||
| [default] VM booted and ready for use! | ||
| ``` | ||
|
|
||
| <p>Para parar totalmente la máquina virtual podemos ejecutar <code>vagrant halt</code>. Luego tendremos que usar <code>vagrant up</code> otra vez para arrancar la máquina.</p> | ||
|
|
||
| <p>Una de las órdenes más útiles es <code>vagrant package</code>. Esto empaquetará la maquina virtual, en el estado en que se encuentre, en un fichero llamado <code>package.box</code>. Este fichero se puede compartir y distribuir para recrear fácilmente la máquina virtual. Si luego usamos <code>vagrant destroy</code> para borrar la máquina virtual, la podemos recuperar después con la misma orden <code>vagrant box add</code> que usamos la primera vez.</p> | ||
|
|
||
| <p>Con esto finaliza nuestro repaso a Vagrant, que es una gran solución para capturar las dependencias de nuestras aplicaciones Rails y aislarlas en un entorno virtualizado que se puede luego empaquetar y distribuir entre otros desarrolladores, o como entorno de preproducción. Vagrant es todavía más útil cuando se utiliza en conjunto con Chef, lo que veremos en un episodio futuro.</p> | ||
|
|
||
|
|
||
|
|
||
|
|
||
|
|
||
|
|
Oops, something went wrong.