Instalación de Ruby con rbenv/RVM: Guía Completa para Servidores Linux

Ruby es un lenguaje de programación dinámico y de código abierto enfocado en la simplicidad y productividad. Para administradores de sistemas y desarrolladores que trabajan con aplicaciones Ruby, gestionar múltiples versiones de Ruby en diferentes proyectos es un desafío común. Esta guía completa explora los dos gestores de versiones de Ruby más populares: rbenv y RVM (Ruby Version Manager), proporcionando instrucciones detalladas de instalación, mejores prácticas de configuración y estrategias de resolución de problemas.

Introducción

La gestión de versiones de Ruby es esencial para entornos de desarrollo modernos donde diferentes aplicaciones pueden requerir diferentes versiones de Ruby. Aunque el gestor de paquetes del sistema puede instalar Ruby, típicamente proporciona solo una versión y puede no ofrecer las últimas versiones. Los gestores de versiones de Ruby como rbenv y RVM resuelven este problema permitiéndote instalar y cambiar entre múltiples versiones de Ruby sin problemas.

Entendiendo rbenv vs RVM

rbenv es un gestor de versiones de Ruby ligero que intercepta comandos de Ruby usando ejecutables shim. Se enfoca en hacer una cosa bien: cambiar versiones de Ruby. rbenv no gestiona dependencias de gemas ni proporciona funciones integradas para crear gemsets, haciéndolo más simple y más compatible con la filosofía Unix.

RVM (Ruby Version Manager) es una solución más completa que gestiona tanto versiones de Ruby como gemsets. Modifica tu entorno de shell de manera más agresiva y proporciona funciones adicionales como configuraciones específicas de proyecto, cambio automático y gestión integrada de gemsets.

Ambas herramientas tienen sus méritos, y la elección a menudo se reduce a preferencias personales y requisitos específicos del proyecto. Esta guía cubre ambos enfoques de manera completa.

Prerrequisitos

Antes de instalar rbenv o RVM, asegúrate de que tu sistema cumple los siguientes requisitos:

Requisitos del Sistema

  • Una distribución Linux (Ubuntu, Debian, CentOS, Rocky Linux, o similar)
  • Acceso root o sudo para instalar dependencias
  • Al menos 500MB de espacio libre en disco
  • Conexión activa a internet para descargar versiones de Ruby
  • Conocimiento básico de línea de comandos

Dependencias Requeridas

Tanto rbenv como RVM requieren herramientas de compilación para construir Ruby desde el código fuente. Instala las dependencias apropiadas para tu distribución:

Ubuntu/Debian:

sudo apt update
sudo apt install -y build-essential libssl-dev libreadline-dev zlib1g-dev \
  libsqlite3-dev wget curl git-core libffi-dev libyaml-dev

CentOS/Rocky Linux/RHEL:

sudo yum groupinstall -y "Development Tools"
sudo yum install -y gcc-c++ patch readline readline-devel zlib zlib-devel \
  libyaml-devel libffi-devel openssl-devel make bzip2 autoconf automake \
  libtool bison sqlite-devel

Consideraciones Adicionales:

  • Para servidores de producción, considera las implicaciones de seguridad de compilar software
  • Asegúrate de que tu firewall permita conexiones HTTPS salientes para descargar versiones de Ruby
  • Verifica que tu sistema tenga suficiente RAM para la compilación (se recomienda al menos 1GB)
  • Considera usar un usuario dedicado para el despliegue de aplicaciones en lugar de root

Instalando rbenv

rbenv proporciona un enfoque limpio y simple para la gestión de versiones de Ruby. Es ideal para usuarios que prefieren modificaciones mínimas del shell y control explícito.

Paso 1: Clonar el Repositorio de rbenv

Instala rbenv clonando su repositorio Git en tu directorio home:

git clone https://github.com/rbenv/rbenv.git ~/.rbenv

Paso 2: Configurar el Entorno del Shell

Añade rbenv al PATH de tu shell e inicialízalo automáticamente. El método varía según el shell:

Para Bash (~/.bashrc):

echo 'export PATH="$HOME/.rbenv/bin:$PATH"' >> ~/.bashrc
echo 'eval "$(rbenv init -)"' >> ~/.bashrc
source ~/.bashrc

Para Zsh (~/.zshrc):

echo 'export PATH="$HOME/.rbenv/bin:$PATH"' >> ~/.zshrc
echo 'eval "$(rbenv init -)"' >> ~/.zshrc
source ~/.zshrc

Paso 3: Instalar el Plugin ruby-build

El plugin ruby-build proporciona el comando rbenv install para instalar versiones de Ruby:

mkdir -p "$(rbenv root)"/plugins
git clone https://github.com/rbenv/ruby-build.git "$(rbenv root)"/plugins/ruby-build

Paso 4: Verificar la Instalación

Confirma que rbenv está instalado correctamente:

rbenv --version
curl -fsSL https://github.com/rbenv/rbenv-installer/raw/main/bin/rbenv-doctor | bash

El script rbenv-doctor verifica tu instalación e informa cualquier problema.

Paso 5: Instalar Versiones de Ruby

Lista las versiones de Ruby disponibles:

rbenv install -l

Instala una versión específica de Ruby (por ejemplo, Ruby 3.2.2):

rbenv install 3.2.2

El proceso de compilación puede tomar varios minutos. Una vez completado, verifica la instalación:

rbenv versions

Paso 6: Establecer la Versión de Ruby Predeterminada

Establece una versión de Ruby global predeterminada:

rbenv global 3.2.2

O establece una versión local para un directorio específico:

cd /ruta/al/proyecto
rbenv local 3.1.4

Esto crea un archivo .ruby-version en el directorio, cambiando automáticamente a esa versión de Ruby cuando entras al directorio.

Paso 7: Verificar la Instalación de Ruby

Verifica que Ruby está funcionando correctamente:

ruby --version
which ruby
gem --version

Instalando RVM

RVM proporciona un entorno más rico en funciones con gestión integrada de gemsets y capacidades de automatización adicionales.

Paso 1: Importar Claves GPG

RVM requiere claves GPG para verificación de seguridad:

gpg --keyserver keyserver.ubuntu.com --recv-keys 409B6B1796C275462A1703113804BB82D39DC0E3 7D2BAF1CF37B13E2069D6956105BD0E739499BDB

Si el servidor de claves no está disponible, prueba una alternativa:

gpg --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys 409B6B1796C275462A1703113804BB82D39DC0E3 7D2BAF1CF37B13E2069D6956105BD0E739499BDB

Paso 2: Instalar RVM

Instala RVM con la última versión estable de Ruby:

curl -sSL https://get.rvm.io | bash -s stable --ruby

O instala RVM sin Ruby (para instalar versiones manualmente más tarde):

curl -sSL https://get.rvm.io | bash -s stable

Paso 3: Cargar el Entorno de RVM

Carga el script de RVM en tu shell actual:

source ~/.rvm/scripts/rvm

Para cargar RVM automáticamente en nuevas sesiones de shell, añade esto a la configuración de tu shell:

Para Bash (~/.bashrc):

echo 'source ~/.rvm/scripts/rvm' >> ~/.bashrc

Para Zsh (~/.zshrc):

echo 'source ~/.rvm/scripts/rvm' >> ~/.zshrc

Paso 4: Verificar la Instalación de RVM

Verifica que RVM está instalado correctamente:

rvm --version
type rvm | head -n 1

La salida debe indicar que rvm es una función.

Paso 5: Instalar Versiones de Ruby

Lista las versiones de Ruby disponibles:

rvm list known

Instala una versión específica de Ruby:

rvm install 3.2.2

Instala múltiples versiones:

rvm install 3.2.2 3.1.4 2.7.8

Paso 6: Establecer la Versión de Ruby Predeterminada

Establece una versión de Ruby predeterminada:

rvm use 3.2.2 --default

Cambia entre versiones instaladas:

rvm use 3.1.4

Paso 7: Trabajar con Gemsets

La función gemset de RVM permite entornos de gemas aislados para diferentes proyectos:

Crea un nuevo gemset:

rvm gemset create miproyecto

Usa una versión específica de Ruby con un gemset:

rvm use 3.2.2@miproyecto

Lista todos los gemsets:

rvm gemset list

Establece una versión de Ruby y gemset específicos del proyecto creando archivos .ruby-version y .ruby-gemset:

echo "3.2.2" > .ruby-version
echo "miproyecto" > .ruby-gemset

Configuración

Configuración de rbenv

La configuración de rbenv es mínima por diseño. Los aspectos clave de configuración incluyen:

Versión Global de Ruby

La versión global de Ruby se almacena en ~/.rbenv/version:

cat ~/.rbenv/version

Versiones Locales de Ruby

Las versiones específicas del proyecto se definen en archivos .ruby-version:

echo "3.2.2" > /ruta/al/proyecto/.ruby-version

Plugins de rbenv

Mejora rbenv con plugins adicionales:

rbenv-vars (para variables de entorno):

git clone https://github.com/rbenv/rbenv-vars.git "$(rbenv root)"/plugins/rbenv-vars

rbenv-update (para actualizaciones fáciles):

git clone https://github.com/rkh/rbenv-update.git "$(rbenv root)"/plugins/rbenv-update

Configuración de RVM

RVM ofrece extensas opciones de configuración a través de sus archivos de configuración.

Archivo de Configuración de RVM

El archivo de configuración principal de RVM se encuentra en ~/.rvmrc o /etc/rvmrc para configuraciones a nivel de sistema.

Ejemplo de configuración:

# Auto-limpieza de versiones antiguas de Ruby
export rvm_auto_clean=1

# Establecer versión predeterminada de Ruby
export rvm_default_ruby=ruby-3.2.2

# Confiar automáticamente en archivos .rvmrc específicos del proyecto
export rvm_trust_rvmrcs_flag=1

Configuración Específica del Proyecto

Crea un archivo .rvmrc en el directorio de tu proyecto:

rvm use 3.2.2@miproyecto --create

O usa el enfoque moderno con archivos .ruby-version y .ruby-gemset como se mostró anteriormente.

Instalación a Nivel de Sistema

Para servidores de producción con múltiples usuarios, considera la instalación a nivel de sistema:

rbenv (multi-usuario):

sudo git clone https://github.com/rbenv/rbenv.git /usr/local/rbenv
sudo git clone https://github.com/rbenv/ruby-build.git /usr/local/rbenv/plugins/ruby-build

# Añadir a /etc/profile.d/rbenv.sh
sudo tee /etc/profile.d/rbenv.sh << 'EOF'
export RBENV_ROOT=/usr/local/rbenv
export PATH="$RBENV_ROOT/bin:$PATH"
eval "$(rbenv init -)"
EOF

RVM (multi-usuario):

curl -sSL https://get.rvm.io | sudo bash -s stable
sudo usermod -a -G rvm nombre_usuario

Ejemplos Prácticos

Ejemplo 1: Desarrollo de Aplicación Rails

Configurando un entorno de desarrollo para una aplicación Rails:

Usando rbenv:

cd ~/proyectos
git clone https://github.com/tunombre/rails-app.git
cd rails-app

# Establecer versión de Ruby
rbenv local 3.2.2

# Instalar bundler
gem install bundler

# Instalar dependencias de la aplicación
bundle install

# Verificar entorno
ruby --version
rails --version

Usando RVM:

cd ~/proyectos
git clone https://github.com/tunombre/rails-app.git
cd rails-app

# Crear y usar gemset específico del proyecto
rvm use 3.2.2@rails-app --create
echo "3.2.2" > .ruby-version
echo "rails-app" > .ruby-gemset

# Instalar dependencias
gem install bundler
bundle install

# Verificar entorno
ruby --version
rvm current

Ejemplo 2: Múltiples Aplicaciones con Diferentes Versiones de Ruby

Gestionando múltiples aplicaciones con diferentes requisitos:

# Aplicación 1 (Ruby 3.2.2)
cd ~/apps/app-moderna
rbenv local 3.2.2
gem install bundler
bundle install

# Aplicación 2 (Ruby 2.7.8 - legacy)
cd ~/apps/app-legacy
rbenv local 2.7.8
gem install bundler -v 2.3.26
bundle install

# Verificar ambos entornos
cd ~/apps/app-moderna && ruby --version  # Ruby 3.2.2
cd ~/apps/app-legacy && ruby --version  # Ruby 2.7.8

Ejemplo 3: Script de Despliegue en Producción

Script de despliegue automatizado usando rbenv:

#!/bin/bash
# deploy.sh

set -e

APP_DIR="/var/www/miapp"
RUBY_VERSION="3.2.2"

cd "$APP_DIR"

# Establecer versión de Ruby
export PATH="$HOME/.rbenv/bin:$PATH"
eval "$(rbenv init -)"
rbenv local "$RUBY_VERSION"

# Actualizar código
git pull origin main

# Instalar dependencias
gem install bundler
bundle install --deployment --without development test

# Precompilar assets
bundle exec rake assets:precompile RAILS_ENV=production

# Reiniciar aplicación
sudo systemctl restart miapp

echo "¡Despliegue completado!"

Ejemplo 4: Instalación de Versiones Específicas de Parches de Ruby

Instalación y prueba de múltiples versiones de parches:

# Instalar múltiples versiones de parches
rbenv install 3.2.0
rbenv install 3.2.1
rbenv install 3.2.2

# Probar aplicación con cada versión
for version in 3.2.0 3.2.1 3.2.2; do
  echo "Probando con Ruby $version"
  rbenv shell $version
  ruby --version
  bundle exec rspec
done

# Establecer la versión que funciona
rbenv local 3.2.2

Verificación

Después de la instalación y configuración, verifica tu entorno de Ruby exhaustivamente.

Verificación Básica

# Verificar versión de Ruby
ruby --version

# Verificar ubicación del ejecutable de Ruby
which ruby

# Verificar versión de gem
gem --version

# Verificar bundler
gem install bundler
bundle --version

Verificación Específica de rbenv

# Listar versiones instaladas
rbenv versions

# Mostrar versión actual
rbenv version

# Verificar shims
rbenv shims

# Verificar estado de rbenv
rbenv doctor

Verificación Específica de RVM

# Listar Rubies instalados
rvm list

# Mostrar Ruby y gemset actuales
rvm current

# Verificar función RVM
type rvm | head -n 1

# Verificar gemset
rvm gemset list

Probar la Instalación de Ruby

Crea un script de prueba simple para verificar la funcionalidad de Ruby:

# test_ruby.rb
puts "Versión de Ruby: #{RUBY_VERSION}"
puts "Plataforma: #{RUBY_PLATFORM}"
puts "Rutas de gemas:"
puts Gem.path

require 'openssl'
puts "Versión de OpenSSL: #{OpenSSL::OPENSSL_VERSION}"

require 'json'
data = { test: 'éxito', ruby: RUBY_VERSION }
puts "Prueba JSON: #{data.to_json}"

Ejecuta la prueba:

ruby test_ruby.rb

Resolución de Problemas

Problemas comunes y sus soluciones al trabajar con rbenv y RVM.

Problema 1: Comando No Encontrado Después de la Instalación

Síntoma: rbenv: command not found o rvm: command not found

Solución:

Asegúrate de que el PATH está correctamente configurado:

# Para rbenv
echo 'export PATH="$HOME/.rbenv/bin:$PATH"' >> ~/.bashrc
echo 'eval "$(rbenv init -)"' >> ~/.bashrc
source ~/.bashrc

# Para RVM
source ~/.rvm/scripts/rvm
echo 'source ~/.rvm/scripts/rvm' >> ~/.bashrc

Problema 2: La Versión de Ruby No Cambia

Síntoma: Ejecutar rbenv local o rvm use no cambia la versión de Ruby

Solución para rbenv:

# Rehash shims después de instalar gemas
rbenv rehash

# Verificar archivos .ruby-version conflictivos
find ~ -name .ruby-version

# Verificar que rbenv está correctamente inicializado
rbenv init

Solución para RVM:

# Recargar RVM
rvm reload

# Verificar conflictos de shell
echo $SHELL
rvm get stable --auto-dotfiles

Problema 3: Fallos de Compilación

Síntoma: La instalación de Ruby falla con errores de compilación

Solución:

Asegúrate de que todas las dependencias están instaladas:

# Ubuntu/Debian
sudo apt install -y build-essential libssl-dev libreadline-dev zlib1g-dev

# CentOS/Rocky Linux
sudo yum groupinstall -y "Development Tools"
sudo yum install -y openssl-devel readline-devel zlib-devel

Para errores relacionados con OpenSSL:

# rbenv
RUBY_CONFIGURE_OPTS="--with-openssl-dir=/usr/local/openssl" rbenv install 3.2.2

# RVM
rvm install 3.2.2 --with-openssl-dir=/usr/local/openssl

Problema 4: Errores de Permiso Denegado

Síntoma: Errores de permiso al instalar gemas o versiones de Ruby

Solución:

Nunca uses sudo con rbenv o RVM:

# Incorrecto
sudo gem install rails

# Correcto
gem install rails

Si encuentras errores de permiso, corrige la propiedad:

# Para rbenv
sudo chown -R $(whoami) ~/.rbenv

# Para RVM
sudo chown -R $(whoami) ~/.rvm

Problema 5: Instalación Lenta de Ruby

Síntoma: La compilación de Ruby toma un tiempo extremadamente largo

Solución:

Usa binarios de Ruby precompilados cuando estén disponibles:

# RVM puede usar binarios precompilados
rvm install 3.2.2 --disable-binary

# O usar explícitamente binario
rvm install 3.2.2 --binary

Habilita compilación paralela:

# Establecer MAKE_OPTS para compilaciones paralelas
export MAKE_OPTS="-j 4"
rbenv install 3.2.2

Problema 6: Gemset No Encontrado (RVM)

Síntoma: Gemset 'nombreproyecto' does not exist

Solución:

# Crear el gemset
rvm gemset create nombreproyecto

# Usarlo con Ruby actual
rvm use @nombreproyecto

# O crear archivos de proyecto
echo "3.2.2" > .ruby-version
echo "nombreproyecto" > .ruby-gemset
cd . # Activar RVM para crear gemset

Mejores Prácticas

Mejores Prácticas de Seguridad

  1. Verificar Descargas: Siempre verifica las firmas GPG al instalar RVM
  2. Actualizaciones Regulares: Mantén rbenv/RVM y las versiones de Ruby actualizadas para parches de seguridad
  3. Instalación Mínima: En servidores de producción, solo instala las versiones de Ruby requeridas
  4. Permisos de Usuario: Nunca ejecutes aplicaciones Ruby como root
  5. Seguridad de Gemas: Usa bundle audit para verificar dependencias vulnerables
# Instalar bundler-audit
gem install bundler-audit

# Verificar vulnerabilidades
bundle audit check --update

Mejores Prácticas de Rendimiento

  1. Usar el Último Ruby: Las versiones más nuevas de Ruby a menudo incluyen mejoras de rendimiento
  2. Habilitar JIT: Ruby 3.x incluye compilador MJIT para mejor rendimiento
# Habilitar MJIT
export RUBY_MJIT_ENABLE=1
ruby --jit tu_script.rb
  1. Optimizar Instalación de Gemas: Usa instalación paralela de bundle
bundle install --jobs=4
  1. Cachear Gemas: En entornos CI/CD, cachea el directorio de gemas
# Añadir a configuración de CI
cache:
  paths:
    - vendor/bundle

Mejores Prácticas de Desarrollo

  1. Archivos de Bloqueo de Versión: Siempre confirma .ruby-version en control de versiones
  2. Documentar Dependencias: Mantén un Gemfile y Gemfile.lock actualizados
  3. Probar Múltiples Versiones: Usa CI para probar contra múltiples versiones de Ruby
  4. Entornos Aislados: Usa gemsets (RVM) o modo de despliegue de bundle (rbenv)
# Modo de despliegue de Bundle
bundle install --deployment
  1. Limpiar Versiones Antiguas: Elimina regularmente versiones de Ruby no usadas
# rbenv
rbenv uninstall 3.1.0

# RVM
rvm remove 3.1.0

Mejores Prácticas de Producción

  1. Estabilidad Sobre Funciones: Usa versiones estables de Ruby, no versiones de desarrollo
  2. Entornos Consistentes: Asegúrate de que desarrollo y producción usan versiones idénticas de Ruby
  3. Despliegues Automatizados: Usa herramientas de despliegue como Capistrano o scripts personalizados
  4. Monitoreo: Monitorea el rendimiento del proceso Ruby y el uso de memoria
  5. Respaldo de Configuraciones: Mantén respaldos de .ruby-version, .ruby-gemset y Gemfiles

Ejemplo de configuración de Capistrano:

# config/deploy.rb
set :rbenv_type, :user
set :rbenv_ruby, '3.2.2'
set :rbenv_prefix, "RBENV_ROOT=#{fetch(:rbenv_path)} RBENV_VERSION=#{fetch(:rbenv_ruby)} #{fetch(:rbenv_path)}/bin/rbenv exec"
set :rbenv_map_bins, %w{rake gem bundle ruby rails}

Mejores Prácticas de Colaboración en Equipo

  1. Documentar Elección de Herramienta: Documenta claramente si el proyecto usa rbenv o RVM
  2. Estandarizar Versiones: Asegúrate de que todos los miembros del equipo usan la misma versión de Ruby
  3. Compartir Configuración: Confirma archivos de versión al repositorio
  4. Actualizar Documentación: Mantén las instrucciones de configuración actualizadas en archivos README

Ejemplo de sección README:

## Configuración de Desarrollo

Este proyecto usa Ruby 3.2.2 gestionado con rbenv.

### Configuración Inicial

1. Instalar rbenv: https://github.com/rbenv/rbenv
2. Instalar Ruby: `rbenv install 3.2.2`
3. Instalar dependencias: `bundle install`
4. Ejecutar pruebas: `bundle exec rspec`

Conclusión

La gestión de versiones de Ruby es una habilidad crítica para desarrolladores y administradores de sistemas que trabajan con aplicaciones Ruby. Tanto rbenv como RVM proporcionan soluciones robustas para gestionar múltiples versiones de Ruby, cada uno con ventajas distintas.

Elige rbenv si:

  • Prefieres modificaciones mínimas del shell
  • Quieres un enfoque simple siguiendo la filosofía Unix
  • No necesitas gestión integrada de gemsets
  • Valoras el control explícito sobre tu entorno

Elige RVM si:

  • Necesitas gestión integrada de gemsets
  • Quieres cambio automático de entorno
  • Prefieres herramientas ricas en funciones con automatización integrada
  • Trabajas con múltiples proyectos que requieren entornos de gemas aislados

Independientemente de tu elección, seguir las mejores prácticas descritas en esta guía asegurará un entorno de desarrollo Ruby estable, seguro y eficiente. Las actualizaciones regulares, las pruebas adecuadas y la adhesión a las directrices de seguridad mantendrán la salud de tus instalaciones de Ruby a lo largo del tiempo.

El ecosistema Ruby continúa evolucionando con cada versión trayendo mejoras de rendimiento, mejoras de seguridad y nuevas funciones. Al dominar la gestión de versiones de Ruby con rbenv o RVM, estableces una base sólida para desarrollar e implementar aplicaciones Ruby con éxito en cualquier entorno.

Recuerda que la elección entre rbenv y RVM no es permanente—puedes cambiar entre ellos si tus necesidades cambian. Lo más importante es entender cómo aprovechar estas herramientas de manera efectiva para mantener entornos Ruby consistentes y reproducibles en sistemas de desarrollo, staging y producción.

Con el conocimiento obtenido de esta guía completa, ahora estás equipado para instalar, configurar y solucionar problemas de instalaciones de Ruby con confianza, permitiéndote enfocarte en construir grandes aplicaciones en lugar de luchar con problemas de entorno.