Configurar el entorno de desarrollo de Ruby on Rails con Docker y Docker Compose en Ubuntu

Docker es un proyecto de código abierto que proporciona una plataforma abierta para que desarrolladores y administradores de sistemas construyan, empaqueten y ejecuten aplicaciones en cualquier lugar como un contenedor ligero. Docker automatiza el despliegue de aplicaciones dentro de contenedores de software.

Ruby on Rails (RoR) es un marco de aplicaciones web de código abierto, publicado bajo la licencia MIT. Es un marco de aplicación web del lado del servidor que sigue el concepto MVC (Modelo-Vista-Controlador).

En este tutorial, te mostraré cómo configurar un entorno de desarrollo para aplicaciones Ruby on Rails utilizando Docker y Docker compose. Utilizaremos Ubuntu 18.04 como sistema operativo anfitrión y usaremos la base de datos PostgreSQL para nuestro proyecto Rails.

Lo que haremos

1. Instalar Docker y Docker Compose
2. Generar el proyecto Rails
3. Configurar el proyecto Rails
4. Crear el script Docker Compose
5. Construir el proyecto
6. Prueba Crear CRUD básico en Rails

Paso 1 – Instalar Docker y Docker Compose

El primer paso que debemos hacer es instalar el docker y el propio docker compose. Instalaremos el docker desde el repositorio oficial de docker, e instalaremos el docker-compose desde el proyecto GitHub oficial de docker.

Antes de instalar los paquetes Docker, ejecuta el siguiente comando apt para instalar las dependencias de los paquetes.

sudo apt install -y \
     apt-transport-https \
     ca-certificates \
     curl \
     software-properties-common

Ahora añade la clave docker y el repositorio docker.

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
 sudo add-apt-repository \
    "deb [arch=amd64] https://download.docker.com/linux/ubuntu \
    $(lsb_release -cs) \
    stable"

El comando actualizará automáticamente todos los repositorios del sistema. Cuando se complete, instala los paquetes docker-ce.

sudo apt install -y docker-ce

Espera a que se instale docker-ce y, a continuación, inicia el servicio docker y añádelo al tiempo de arranque.

sudo systemctl start docker
 sudo systemctl enable docker

El Docker está funcionando en el sistema.

A continuación, instala docker-compose descargando el archivo binario directamente desde el repositorio GitHub de docker.

Descarga el archivo binario de docker-compose en el directorio ‘/usr/local/bin/’ y conviértelo en un ejecutable.

sudo curl -L https://github.com/docker/compose/releases/download/1.21.0/docker-compose-$(uname -s)-$(uname -m) -o /usr/local/bin/docker-compose
 sudo chmod +x /usr/local/bin/docker-compose

El docker y el docker-compose han sido instalados en el sistema, comprueba la versión utilizando los comandos siguientes.

docker version
 docker-compose version

A continuación se muestra el resultado.

Paso 2 – Generar el proyecto Ruby on Rails

Después de instalar los paquetes principales docker y docker-compose en el sistema, queremos crear un nuevo usuario y luego generar el proyecto Rails utilizando las imágenes docker.

Añade un usuario llamado ‘hakase’ y dale una contraseña.

useradd -m -s /bin/bash hakase
 passwd hakase

Añade el usuario al grupo ‘sudo’ y ‘docker’ y accede al shell del usuario ‘hakase’.

usermod -a -G sudo hakase
 usermod -a -G docker hakase
 su - hakase

Ahora el usuario ‘hakase’ puede ejecutar y poner en marcha el comando docker.

A continuación, crearemos un nuevo directorio ‘rails’ para nuestro proyecto Ruby on Rails.

Crea el directorio ‘rails’ y accede a él.

mkdir -p ~/rails
 cd ~/rails/

Ahora ejecuta el comando ‘docker run’ que aparece a continuación.

docker run --rm -v ${PWD}:/usr/src -w /usr/src -ti ruby:alpine sh ; cd app

El comando ejecutará el contenedor temporal basado en la imagen ruby:alpine, montará el directorio local en el directorio ‘/usr/src’ dentro del contenedor, y luego ejecutará el comando shell ‘sh’ y se dirigirá al directorio ‘app’.

Dentro del contenedor, instala los paquetes ‘build-base’.

apk add build-base

Ahora instala el Ruby on Rails dentro del contenedor temporal.

gem install -N rails

Y genera el nuevo proyecto Rails llamado ‘app’ con PostgreSQL como base de datos, luego sal/cierra la sesión del contenedor.

rails new app --database=postgresql --skip-bundle
 exit

Y estarás en el directorio del proyecto Rails ‘app’.

Ahora cambia el propietario del directorio del proyecto ‘app’ por el usuario ‘hakase’.

sudo chown -R hakase:hakase ~/rails/app/
 ls -lah

Y el proyecto Ruby on Rails se ha generado a través del contenedor docker temporal.

Paso 3 – Configurar el proyecto Rails

En este paso, crearemos un nuevo Dockerfile para nuestras aplicaciones Rails.

Dentro del directorio ‘rails’, crea un nuevo Dockerfile utilizando vim.

vim Dockerfile

Pega la configuración de abajo.

FROM ruby:alpine

RUN apk update
RUN apk add build-base nodejs postgresql-dev tzdata
RUN gem install -N rails

RUN mkdir -p /app
WORKDIR /app

COPY ./app/Gemfile /app
COPY ./app/Gemfile.lock /app
RUN bundle install --binstubs

Guarda y sal.

Estamos creando una nueva imagen Docker basada en el linux Ruby Alpine. Vamos a instalar nuevos paquetes para la instalación de rails, crea un nuevo directorio /app, copia el Gemfile y Gemfile.lock del directorio local de app, e instala todos los paquetes basados en el Gemfile.

A continuación, ve al directorio ‘app’, crea un nuevo archivo Gemfile.lock.

cd app/
 touch Gemfile.lock

Edita el archivo ‘database.yml’.

vim config/database.yml

Cambia la configuración de la base de datos por defecto y modifica los detalles como se indica a continuación.

default: &default
   adapter: postgresql
   encoding: unicode
   host: db
   username: postgres
   pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
   timeout: 5000

Guarda y sal.

La configuración del proyecto Rails se ha completado.

Paso 4 – Crear un archivo Docker Compose

En este paso, crearemos un nuevo archivo docker-compose para nuestra aplicación Rails. Sólo crearemos dos servicios db base de datos PostgreSQL y web es la propia aplicación rails.

Crea un nuevo archivo ‘docker-compose.yml’ dentro del directorio ‘rails’.

vim docker-compose.yml

Y pega la configuración de abajo.

version: '3.6'

services:

  db:
    image: postgres:alpine
    volumes:
      - ./postgresql:/var/lib/postgresql/data

  web:
    build: .
    volumes:
      - ./app:/app
    working_dir: /app
    command: bundle exec rails s -p 3000 -b '0.0.0.0'
    ports:
      - 80:3000
    depends_on:
      - db

Guarda y sal.

Ahora crea el directorio ‘postgresql’ dentro del proyecto ‘rails’.

mkdir -p ~/rails/postgresql

Y ya estamos listos para construir nuestro proyecto Rails.

Paso 5 – Construir el proyecto

Construye la imagen docker de Rails utilizando el comando docker-compose de abajo.

docker-compose build

El comando descargará la imagen Ruby Alpine Linux y construirá la imagen personalizada que necesitemos basándose en nuestro Dockerfile.

Genera la base de datos PostgreSQL para el proyecto.

docker-compose run web rake db:create

Ahora pon en marcha los servicios ‘db’ y ‘web’.

docker-compose up -d

Y los servicios ‘rails’ están en marcha, compruébalo con el comando docker-compose de abajo.

docker-compose ps

Puedes ver que el servicio ‘web’ se está ejecutando en el puerto ’80’ del host.

Ahora comprueba las imágenes docker en nuestro sistema.

docker-compose images

Y obtendrás el resultado que se muestra a continuación.

Ahora abre tu navegador web y escribe la dirección IP o el nombre de dominio del servidor. El mío es

http://rails.hakase-labs.io/

Y obtendrás la aplicación de la página Rails por defecto.

Ahora estamos listos para desarrollar nuestro proyecto Rails.

Paso 6 – Prueba de crear un CRUD básico en Rails

Genera un CRUD simple en Rails ejecutando el comando rails dentro del servicio contenedor ‘web’.

docker-compose exec web rails g scaffold Post title:string body:text

Ahora genera la base de datos.

docker-compose exec web rake db:migrate

Ahora abre tu navegador web y escribe la dirección IP del servidor en la barra de direcciones con la ruta ‘/posts’. La mía es

http://rails.hakase-labs.io/posts

Y obtendrás la sencilla página CRUD que aparece a continuación.

Escribe la entrada y haz clic en el botón ‘Crear entrada’.

Y obtendrás el resultado que se muestra a continuación.

La configuración del entorno de desarrollo para Ruby on Rails con Docker y Docker Compose se ha completado con éxito.

Referencia

• https://docs.docker.com/