Ruby on Rails con Docker para un entorno de desarrollo local

¡Hola, desarrolladores de Ruby! Si has estado buscando una forma efectiva de configurar Ruby on Rails con Docker para tu entorno de desarrollo local, esta publicación es para ti. Es la continuación de nuestro artículo anterior sobre cómo instalar Ruby en macOS para el desarrollo local.

Al desarrollar un proyecto de Ruby on Rails, los desarrolladores de Ruby suelen tener que considerar una base de datos y otros requisitos previos del entorno de desarrollo. Sin embargo, puede ser difícil asegurarse de que todo esté instalado en el sistema operativo host y que use las versiones exactas necesarias.

Cada vez que intentaba crear un proyecto nuevo, deseaba tener un botón que creara un entorno nuevo y limpio para el proyecto. Así que decidí crear una configuración con Docker que se puede iniciar y detener fácilmente con docker-compose.yml de Docker.

¿Qué es Docker Compose?

Docker Compose es una herramienta de Infraestructura como Código (IaC) que te permite configurar y conectar aplicaciones y servicios, como proxies, bases de datos y montajes de volúmenes, para aprovisionarlos de forma reutilizable. Se instala como parte del paquete de software de Docker y se define con YAML.

Esta configuración de Docker Compose para un entorno de desarrollo local se puede usar en distintos tipos de proyectos; no es exclusiva de Ruby on Rails. También puede usarse en proyectos personales o proyectos de frontend del lado del cliente. Estas son las principales razones por las que prefiero usar entornos de Docker en lugar de modificar mi propio sistema operativo host:

• fácil de configurar

• fácil de separar la lógica del entorno

• fácil de usar el mismo entorno para distintos proyectos

• fácil de compartir el entorno con quien necesite ayuda, sin incluir código confidencial

• la máquina host se mantiene limpia

Una configuración de Ruby on Rails con Docker

Para configurar un entorno de Ruby on Rails con Docker para el desarrollo local, necesitarás lo siguiente:

• Un sistema operativo tipo Unix (yo uso macOS, pero puedes usar Ubuntu u otra distribución de Linux. Windows también debería funcionar)

• Git

• make (versión 3.81 o posterior)

• Docker (versión 19.03.12 o posterior)

• docker-compose (versión 1.26.0 o posterior)

• Tu editor de texto preferido (en mi caso, Visual Studio Code)

Una vez que tengas todo eso, ya puedes empezar. Si no quieres leer, aquí está el repositorio de código abierto con todas las instrucciones necesarias y el código fuente completo de los fragmentos que revisaremos. Pero como ya estás aquí, sigue este artículo paso a paso.

Para empezar, crearé un proyecto de Ruby on Rails llamado foo_bar_project, para simplificar.

1) Obtén la configuración del entorno de Docker Compose y elimina el repositorio de Git. Si quieres mantener todo bajo el seguimiento de un repositorio de código fuente de Git, puedes crear el tuyo más adelante.

1git clone git@github.com:mtereschenko/simple_ror_environment.git && cd simple_ror_environment && rm -rf .git

Los siguientes pasos deben ejecutarse en el directorio ./environment, así que asegúrate de ejecutar los comandos allí:

1cd ./environment

2) Ahora, debes asignar un nombre de proyecto a esta configuración del entorno. De forma predeterminada, es test_project. En el ejemplo de código que veremos aquí, debemos cambiarlo a foo_bar_project, como indicamos antes. Para hacerlo, modifica el archivo ./environment/.env.example para que la variable PROJECT_NAME refleje ese nombre. Es importante usar Snake Case en minúsculas como valor de las variables:

1PROJECT_NAME=foo_bar_project

3) Ahora puedes crear tu proyecto con el siguiente comando:

1make init

Como puedes ver, ahora tienes una carpeta nueva llamada application que contiene código de Ruby on Rails.

4) Ahora debes compilar tu entorno de desarrollo local con Docker Compose. Este paso es obligatorio después de cualquier cambio en el Dockerfile o el Gemfile de tu aplicación.

1make build

5) Ahora puedes iniciar el entorno de desarrollo local de Ruby de la siguiente manera:

1make start

Ten en cuenta que esto todavía no inicia una aplicación de Ruby on Rails. Para hacerlo, debemos abrir una shell en el entorno de Docker e indicarle que inicie el proceso rails. Lo haremos así:

1make shell
2rails s -p 3000 –binding=0.0.0.0

Ruby on Rails con Docker para un entorno de desarrollo local. Por último, si abres el navegador y vas a esta URL, http://foo_bar_project.localhost/, deberías ver el proyecto de Ruby on Rails que acabamos de crear.

Entonces, ¿qué tenemos disponible ahora?

• Tenemos un proyecto con un directorio de entorno que contiene todo lo necesario para ejecutarlo, y un directorio de aplicación que contiene el código de nuestra aplicación. Este directorio está vinculado al contenedor de Docker, por lo que tienes acceso completo desde la imagen de Ruby de Docker.

• Tenemos acceso rápido a la shell de Ruby, así que no necesitamos instalar localmente un entorno de Ruby, como Rails, Rake, Bundler u otra herramienta de Ruby.

• Los comandos se pueden ejecutar después del comando make shell.

• Esta configuración de Docker Compose del proyecto incluye dos etapas preconfiguradas. Si alguna vez necesitas implementar tu aplicación de Ruby en otro lugar, puedes crear tu propia etapa. ¡Así de simple!

Si quieres saber cómo funciona el entorno de Docker para Ruby on Rails que vimos, vamos a desglosarlo en la imagen de Ruby para Docker, el Makefile y la definición de Docker Compose que hace que todo funcione en conjunto.

Una imagen de Ruby para Docker

Para empezar, la imagen de Ruby para Docker es una parte esencial. También es importante crearla correctamente para reutilizar de forma efectiva la caché de las capas de la imagen de Docker y tener en cuenta otros aspectos relacionados con un entorno de desarrollo local.

A continuación se muestra el Dockerfile para la imagen de Ruby de Docker:

1FROM ruby:2.7.6-alpine3.16 as base_image
2RUN apk add --no-cache git \
3    build-base \
4    libpq-dev \
5    tzdata
6
7FROM base_image as development
8COPY ./artifacts/rails/Gemfile /tmp/Gemfile
9COPY ./artifacts/rails/Gemfile.lock /tmp/Gemfile.lock
10COPY ./containers/ruby/runners/runner.development.sh /rdebug_ide/runner.sh
11RUN cd /tmp && \
12  gem install ruby-debug-ide && \
13  gem install debase && \
14  bundle install && \
15  chmod +x /rdebug_ide/runner.sh && \
16  apk add --no-cache git \
17  nodejs \
18  yarn
19WORKDIR /app
20
21ENTRYPOINT ["tail", "-f", "/dev/null"]
22
23FROM base_image as init
24COPY ./containers/ruby/initializers/runner.init.sh /tmp/runner.sh
25COPY ./containers/ruby/initializers/database.yml /tmp/database.yml
26COPY ./containers/ruby/initializers/.gitignore /tmp/.gitignore
27COPY ./containers/ruby/initializers/development.rb /tmp/development.rb
28RUN chmod +x /tmp/runner.sh
29
30WORKDIR /app
31
32ENTRYPOINT ["/tmp/runner.sh"]

Como puedes ver, da por sentada cierta configuración adicional necesaria para tener un entorno funcional de aplicaciones de Ruby on Rails, por ejemplo:

• El archivo database.yml, que contiene los detalles de conexión de Ruby on Rails a la base de datos

• development.rb, para la configuración de ejecución de Ruby on Rails en el entorno de desarrollo

Esto se hace con el script runners.sh en el directorio ./environment/containers/ruby/initializers:

1#!/bin/ash
2
3cd /app
4
5gem install rails
6
7rails new . -d=postgresql --skip-git
8
9yes | cp -rf /tmp/database.yml /app/config/database.yml
10yes | cp -rf /tmp/development.rb /app/config/environments/development.rb
11cp /tmp/.gitignore /app/.gitignore

Este Dockerfile también usa Docker multietapa, de modo que partes específicas se pueden reutilizar de manera efectiva en distintos entornos si quieres usar la misma configuración en diferentes flujos de trabajo (pruebas, preproducción, etc.).

Un archivo Docker Compose para Rails

El archivo Docker Compose en `./environment/docker-compose.development.yml` ayuda a conectar todos los servicios para que una aplicación de Ruby on Rails funcione en Docker:

• Un servidor HTTP nginx

• Una aplicación de Ruby

• Un servidor de base de datos PostgreSQL

A continuación se muestra el archivo Docker Compose para Rails que usa esta configuración:

1version: '3.7'
2services:
3  nginx:
4    image: "${PROJECT_NAME}/nginx:development"
5    container_name: ${PROJECT_NAME}-nginx
6    build: 
7      context: ./
8      dockerfile: ./containers/nginx/Dockerfile
9    depends_on:
10      - ruby
11    tty: true
12    ports:
13      - 80:80
14    volumes:
15      - ./`artifacts`/nginx/:/`var`/log/nginx:cached
16   ruby:
17    image: "${PROJECT_NAME}/ruby:development"
18    container_name: ${PROJECT_NAME}-ruby
19    depends_on:
20      - postgres
21    build:
22      context: ./
23      dockerfile: ./containers/ruby/Dockerfile
24      target: development
25    ports:
26      - 13030:13030
27    volumes:
28      - ${APP_PATH}:/app:cached
29    environment:
30      DB_NAME: ${DB_NAME}
31      PROJECT_NAME: ${PROJECT_NAME}
32      DB_USER: ${DB_USER}
33      DB_PASSWORD: ${DB_PASSWORD}
34      DB_PORT: ${DB_PORT}
35      PUMA_WORKERS: 0
36      RAILS_MAX_THREADS: 1
37     postgres:
38    image: "${PROJECT_NAME}/postgres:development"
39    container_name: ${PROJECT_NAME}-postgres
40    environment:
41      POSTGRES_DB: ${DB_NAME}
42      POSTGRES_USER: ${DB_USER}
43      POSTGRES_PASSWORD: ${DB_PASSWORD}
44    build:
45      context: ./
46      dockerfile: ./containers/postgres/Dockerfile
47    ports:
48      - ${DB_PORT}:5432
49    volumes:
50      - postgres_volume:/var/lib/postgresql/data
51
52volumes:
53  postgres_volume:

Makefile para Docker

Por último, para que los desarrolladores puedan interactuar fácilmente con este entorno de desarrollo local de Ruby mediante una interfaz accesible, se usa un Makefile:

1.PHONY: help
2# Make stuff
3
4-include .env
5
6export DOCKER_BUILDKIT=1
7export COMPOSE_DOCKER_CLI_BUILD=1
8
9.DEFAULT_GOAL := help
10
11ARTIFACTS_DIRECTORY := "./artifacts"
12
13CURRENT_PATH :=${abspath .}
14
15SHELL_CONTAINER_NAME := $(if $(c),$(c),ruby)
16BUILD_TARGET := $(if $(t),$(t),development)
17
18help: ## Help.
19@grep -E '^[a-zA-Z-]+:.*?## .*$$' Makefile | awk 'BEGIN {FS = ":.*?## "}; {printf "[32m%-27s[0m %s\n", $$1, $$2}'
20
21init: ## Project installation.
22@rm -f ./.env
23@cp .env.example .env
24@make init_app_directory
25@make create_postgress_volume
26@docker-compose -f docker-compose.init.yml build
27@docker-compose -f docker-compose.init.yml up
28
29build: ## Build images.
30@make create_project_artifacts
31@cp ${APP_PATH}/Gemfile "${ARTIFACTS_DIRECTORY}/rails/Gemfile"
32@cp ${APP_PATH}/Gemfile.lock "${ARTIFACTS_DIRECTORY}/rails/Gemfile.lock"
33@docker-compose -f docker-compose.$(BUILD_TARGET).yml build
34
35shell: ## Internal image bash command line.
36@if [[ -z `docker ps | grep ${SHELL_CONTAINER_NAME}` ]]; then \
37echo "${SHELL_CONTAINER_NAME} is NOT running (make start)."; \
38else \
39docker-compose -f docker-compose.$(BUILD_TARGET).yml exec $(SHELL_CONTAINER_NAME) /bin/ash; \
40fi
41
42start: ## Start previously builded application images.
43@make create_project_artifacts
44@make start_postgres
45@make start_ruby
46@make start_nginx
47
48run: ## Run ruby debugger session.
49@docker-compose -f docker-compose.$(BUILD_TARGET).yml exec ruby /bin/ash /rdebug_ide/runner.sh
50
51start_ruby: ## Start ruby image.
52@if [[ -z `docker ps | grep ruby` ]]; then \
53docker-compose -f docker-compose.$(BUILD_TARGET).yml up -d ruby; \
54else \
55echo "Ruby is running."; \
56fi
57
58start_postgres: ## Start postgres image.
59@if [[ -z `docker ps | grep postgres` ]]; then \
60docker-compose -f docker-compose.$(BUILD_TARGET).yml up -d postgres; \
61else \
62echo "Postgres is running."; \
63fi
64
65start_nginx: ## Start nginx image.
66@if [[ -z `docker ps | grep nginx` ]]; then \
67docker-compose -f docker-compose.$(BUILD_TARGET).yml up -d nginx; \
68else \
69echo "Nginx is running."; \
70fi
71
72stop: ## Stop all images.
73@docker-compose -f docker-compose.$(BUILD_TARGET).yml stop
74
75create_project_artifacts:
76mkdir -p ./artifacts/rails
77mkdir -p ./artifacts/db
78
79init_app_directory:
80@mkdir -p ${APP_PATH}
81
82create_postgress_volume:
83@sed -i '' -r  "s/postgres_volume:/${PROJECT_NAME}_db_volume:/g" docker-compose.development.yml

Ejecutar aplicaciones de Ruby de forma eficiente

Esperamos que ahora hayas aprendido a ejecutar aplicaciones de Ruby, como Ruby on Rails, en tu entorno local mediante la configuración de contenedores de Docker. Otra forma de ejecutar aplicaciones de Ruby localmente es usar entornos virtuales de Ruby, un tema que ya abordamos en nuestra publicación sobre cómo instalar Ruby en macOS.

Ahora que ya tienes listo tu entorno de desarrollo de Ruby, quizás también quieras aprender a proteger tus aplicaciones de Ruby. Consulta estos artículos para obtener más información sobre la seguridad de Ruby:

• Analizar gems de Ruby con Snyk

• Guía definitiva para administrar dependencias de gems de Ruby