---
title: "Cómo instalar Ruby con rbenv en Ubuntu 24.04"
description: "Instala rbenv y ruby-build en Ubuntu 24.04, compila la versión de Ruby que necesites, fija una versión por proyecto con .ruby-version y usa Bundler."
category: "Despliegue de Aplicaciones"
language: es
source: https://cubepath.com/es/docs/despliegue-de-aplicaciones/instalacion-de-ruby-con-rbenv-rvm
updated: 2026-09-25
---

# Cómo instalar Ruby con rbenv en Ubuntu 24.04

rbenv es un gestor de versiones de Ruby que permite tener varias versiones instaladas en el mismo servidor y elegir cuál usa cada proyecto, sin tocar el Ruby del sistema. Funciona con "shims": pequeños ejecutables que interceptan `ruby`, `gem` o `bundle` y los redirigen a la versión que corresponde según el directorio en el que estés. En este tutorial instalarás rbenv y su plugin ruby-build en Ubuntu 24.04, compilarás Ruby, fijarás una versión por proyecto y gestionarás las gemas con Bundler.

## rbenv o RVM

RVM es la alternativa clásica. Ambos resuelven el mismo problema, pero con enfoques distintos:

| | rbenv | RVM |
|---|---|---|
| Cómo cambia de versión | Shims en el `PATH` | Redefine `cd` y funciones del shell |
| Aislamiento de gemas | Bundler por proyecto | Gemsets propios además de Bundler |
| Instalación | `git clone` de dos repositorios | Script de instalación con verificación GPG |
| Intrusividad en el shell | Mínima | Alta |

Hoy Bundler ya aísla las gemas de cada proyecto mediante `Gemfile.lock`, así que los gemsets de RVM aportan poco. Esta guía usa rbenv, que es más sencillo, predecible y el que recomiendan la mayoría de proyectos Rails. No instales rbenv y RVM a la vez en el mismo usuario: se pisan el `PATH`.

## Requisitos previos

- Un servidor con Ubuntu 24.04 LTS, por ejemplo un VPS de CubePath.
- Un usuario no root con privilegios `sudo`. rbenv se instala en el directorio personal de ese usuario, sin `sudo`.
- Al menos 2 GB de RAM (o swap): compilar Ruby con poca memoria puede fallar.
- Unos 1,5 GB libres en disco por cada versión de Ruby.

## Paso 1: Instalar las dependencias de compilación

ruby-build compila Ruby desde el código fuente, así que necesita un compilador y las librerías de desarrollo de OpenSSL, YAML, zlib, libffi y GMP. `rustc` es opcional y habilita YJIT, el compilador JIT de Ruby:

```bash
sudo apt update
sudo apt install git curl build-essential autoconf libssl-dev libyaml-dev zlib1g-dev libffi-dev libgmp-dev libreadline-dev rustc
```

Comprueba que el compilador está disponible:

```bash
gcc --version | head -n 1
```

```output
gcc (Ubuntu 13.3.0-6ubuntu2~24.04) 13.3.0
```

## Paso 2: Instalar rbenv

Clona el repositorio de rbenv en `~/.rbenv`:

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

Añade la inicialización de rbenv a `~/.bashrc`. Esta línea pone rbenv en el `PATH`, activa los shims y el autocompletado cada vez que abres una sesión:

```bash
echo 'eval "$(~/.rbenv/bin/rbenv init - bash)"' >> ~/.bashrc
```

Recarga la configuración del shell:

```bash
source ~/.bashrc
```

Comprueba que el comando `rbenv` es una función del shell, lo que indica que la inicialización es correcta:

```bash
type rbenv | head -n 1
```

```output
rbenv is a function
```

> Nota: si usas zsh, cambia `bash` por `zsh` y `~/.bashrc` por `~/.zshrc` en el comando anterior.

## Paso 3: Instalar el plugin ruby-build

rbenv solo cambia entre versiones; el comando `rbenv install`, que descarga y compila Ruby, lo aporta el plugin ruby-build. Clónalo en el directorio de plugins de rbenv:

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

Lista las versiones estables disponibles:

```bash
rbenv install --list
```

```output
3.2.9
3.3.9
3.4.7
jruby-10.0.2.0
mruby-3.4.0
truffleruby-25.0.0
truffleruby+graalvm-25.0.0
Only latest stable releases for each Ruby implementation are shown.
Use `rbenv install --list-all' to show all local versions.
```

Tu lista mostrará las versiones vigentes cuando ejecutes el comando. Las líneas que son solo números corresponden a CRuby, el Ruby estándar.

## Paso 4: Compilar e instalar Ruby

Instala la versión que necesite tu proyecto. En este tutorial se usa `3.4.7` como ejemplo; sustitúyela por la más reciente de tu lista o por la que indique el proyecto:

```bash
rbenv install 3.4.7
```

La compilación tarda entre 3 y 10 minutos según la CPU. Al terminar verás:

```output
==> Installed ruby-3.4.7 to /home/your_user/.rbenv/versions/3.4.7
```

Define esa versión como la predeterminada para tu usuario:

```bash
rbenv global 3.4.7
```

Comprueba qué Ruby se está usando y de dónde sale:

```bash
ruby -e 'puts RUBY_VERSION'
which ruby
rbenv version
```

```output
3.4.7
/home/your_user/.rbenv/shims/ruby
3.4.7 (set by /home/your_user/.rbenv/version)
```

Si `which ruby` devuelve `/usr/bin/ruby`, el shim no está por delante en el `PATH`: revisa el paso 2.

Si instalaste `rustc`, puedes comprobar que YJIT está disponible:

```bash
ruby --yjit -e 'puts RubyVM::YJIT.enabled?'
```

```output
true
```

## Paso 5: Instalar gemas y Bundler

Las gemas se instalan dentro de la versión de Ruby activa, en `~/.rbenv/versions/<versión>/`, así que nunca necesitas `sudo`. Para ahorrar tiempo y espacio en un servidor, desactiva la generación de documentación local de las gemas:

```bash
echo "gem: --no-document" > ~/.gemrc
```

Bundler viene incluido con Ruby. Actualízalo a la última versión y compruébalo:

```bash
gem install bundler
bundle -v
```

```output
Bundler version 2.7.2
```

Cuando instalas una gema que trae ejecutables, rbenv crea su shim automáticamente. Por ejemplo:

```bash
gem install rails
rails -v
```

Si alguna vez un ejecutable recién instalado no se encuentra, regenera los shims con `rbenv rehash`.

## Paso 6: Fijar una versión de Ruby por proyecto

Cada proyecto puede usar una versión distinta de la global. rbenv la lee de un archivo `.ruby-version` en el directorio del proyecto (o en cualquiera de sus padres). Instala otra versión para probarlo:

```bash
rbenv install 3.3.9
```

Crea un proyecto y fija en él esa versión:

```bash
mkdir ~/proyecto-antiguo
cd ~/proyecto-antiguo
rbenv local 3.3.9
cat .ruby-version
ruby -e 'puts RUBY_VERSION'
```

```output
3.3.9
3.3.9
```

Fuera de ese directorio vuelve a usarse la versión global:

```bash
cd ~
ruby -e 'puts RUBY_VERSION'
```

```output
3.4.7
```

Versiona `.ruby-version` junto con el `Gemfile` y el `Gemfile.lock`. Así cualquier servidor con rbenv usará la misma versión de Ruby y, con `bundle install`, las mismas versiones de gemas. En un proyecto nuevo el flujo típico es:

```bash
cd ~/proyecto-antiguo
bundle init
bundle add rack
bundle install
```

`bundle init` crea el `Gemfile`, `bundle add` añade la dependencia y `bundle install` genera `Gemfile.lock` con las versiones exactas.

## Paso 7: Mantener rbenv y eliminar versiones

Las definiciones de nuevas versiones de Ruby llegan con ruby-build. Si `rbenv install --list` no muestra una versión recién publicada, actualiza los dos repositorios:

```bash
git -C ~/.rbenv pull
git -C "$(rbenv root)"/plugins/ruby-build pull
```

Lista las versiones instaladas; la activa aparece marcada con un asterisco:

```bash
rbenv versions
```

```output
  3.3.9
* 3.4.7 (set by /home/your_user/.rbenv/version)
```

Elimina las que ya no uses para liberar espacio:

```bash
rbenv uninstall 3.3.9
```

## Solución de problemas

**`rbenv: command not found` tras abrir una sesión nueva.** La línea de inicialización no está en el archivo que lee tu shell. Comprueba con `grep rbenv ~/.bashrc` que existe y abre una sesión nueva. En sesiones SSH no interactivas (por ejemplo, desde herramientas de despliegue) `~/.bashrc` no se carga; en ese caso llama a los binarios con su ruta, como `~/.rbenv/shims/bundle`, o ejecuta `~/.rbenv/bin/rbenv exec bundle install`.

**Ruby no muestra la versión esperada.** Ejecuta `rbenv version`: indica qué archivo fija la versión. Una variable `RBENV_VERSION` exportada o un `.ruby-version` en un directorio padre tienen prioridad sobre la versión global.

**La compilación falla.** ruby-build guarda el log completo en `/tmp` e indica la ruta al fallar, algo como `/tmp/ruby-build.20260925101500.12345.log`. Revisa las últimas líneas:

```bash
tail -n 40 /tmp/ruby-build.*.log
```

Los errores `psych: Could not be configured` o `openssl: Could not be configured` indican que falta `libyaml-dev` o `libssl-dev`; instálalos con el comando del paso 1 y repite `rbenv install`. Si el proceso muere sin error claro, suele ser falta de memoria: añade swap o compila con `MAKE_OPTS="-j1" rbenv install 3.4.7`.

**`Gem::FilePermissionError` al instalar gemas.** Estás usando el Ruby del sistema en lugar del de rbenv. Comprueba con `which gem` que la ruta es `~/.rbenv/shims/gem` y no uses `sudo gem install`.

## Conclusión

Has instalado rbenv y ruby-build en Ubuntu 24.04, has compilado Ruby, has fijado versiones distintas por proyecto con `.ruby-version` y gestionas las gemas con Bundler sin `sudo`. Como siguientes pasos puedes crear una aplicación Rails, ejecutarla con Puma como servicio de systemd y poner Nginx delante como proxy inverso con un certificado TLS.