Docker pour Ruby on Rails dans un environnement de développement local

Bonjour les développeurs Ruby ! Si vous cherchez une solution efficace pour configurer Docker pour Ruby on Rails dans votre environnement de développement local, cet article est fait pour vous. Il fait suite à notre précédent article sur l’installation de Ruby sur macOS pour le développement local.

Lorsqu’ils développent un projet Ruby on Rails, les développeurs Ruby doivent souvent prévoir une base de données, ainsi que d’autres prérequis pour l’environnement de développement. Cependant, installer tous ces éléments sur le système d’exploitation de votre machine hôte et utiliser exactement les versions requises peut parfois s’avérer difficile.

Chaque fois que j’essayais de créer un nouveau projet, je me disais qu’il me faudrait un bouton pour créer un environnement propre. J’ai donc décidé de créer une configuration basée sur Docker, que l’on peut facilement démarrer et arrêter à l’aide de docker-compose.yml de Docker.

Qu’est-ce que Docker Compose ?

Docker Compose est un outil d’infrastructure as code (IaC) qui vous permet de configurer et de connecter des applications et des services, tels que des proxys, des bases de données et des montages de volumes, afin de les mettre à disposition de manière réutilisable. Il est installé avec le pack logiciel Docker et sa configuration est définie en YAML.

Cette configuration Docker Compose pour un environnement de développement local peut être utilisée pour différents types de projets ; elle ne se limite pas à Ruby on Rails. Elle peut aussi servir pour des projets personnels ou des projets front-end côté client. Voici les principales raisons pour lesquelles je préfère utiliser des environnements Docker plutôt que de modifier le système d’exploitation de ma machine hôte :

• facile à configurer

• facile de séparer la logique de l’environnement

• facile d’utiliser le même environnement pour différents projets

• facile de partager l’environnement avec toute personne qui a besoin d’aide, sans exposer de code sensible

• la machine hôte reste propre

Une configuration Docker pour Ruby on Rails

Pour configurer un environnement Docker pour Ruby on Rails destiné au développement local, vous aurez besoin des éléments suivants :

• Un système d’exploitation de type Unix (j’utilise macOS, mais vous pouvez utiliser Ubuntu ou toute autre distribution Linux. Windows devrait également fonctionner)

• Git

• make (version 3.81 ou ultérieure)

• Docker (version 19.03.12 ou ultérieure)

• docker-compose (version 1.26.0 ou ultérieure)

• Votre éditeur de texte préféré (Visual Studio Code dans mon cas)

Une fois que vous avez tout cela, vous pouvez commencer. Si vous préférez passer directement à la pratique, voici le dépôt open source qui contient toutes les instructions nécessaires et le code source complet des extraits que nous allons examiner. Mais puisque vous êtes déjà ici, suivez cet article pour découvrir le processus étape par étape.

Pour commencer, je vais créer un projet Ruby on Rails nommé foo_bar_project, par souci de simplicité.

1) Récupérez la configuration de l’environnement Docker Compose et supprimez le dépôt Git. Si vous souhaitez suivre l’ensemble des modifications dans un dépôt de code source Git, vous pourrez créer le vôtre par la suite.

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

Les étapes suivantes doivent être exécutées dans le répertoire ./environment. Vérifiez donc que vous exécutez les commandes depuis ce répertoire :

1cd ./environment

2) Attribuez ensuite un nom de projet à cette configuration d’environnement. Par défaut, il s’agit de test_project. Dans notre exemple, nous devons le remplacer par foo_bar_project, comme indiqué précédemment. Pour cela, modifiez le fichier ./environment/.env.example afin de définir la variable PROJECT_NAME. Il est important d’utiliser le snake_case (mots séparés par des tirets bas) en minuscules pour les valeurs des variables :

1PROJECT_NAME=foo_bar_project

3) Vous pouvez maintenant créer votre projet en exécutant la commande suivante :

1make init

Comme vous pouvez le constater, un nouveau dossier nommé application contient maintenant le code Ruby on Rails.

4) Vous devez maintenant créer votre environnement de développement local avec Docker Compose. Cette étape est obligatoire après toute modification du Dockerfile ou du Gemfile de votre application.

1make build

5) Vous pouvez maintenant démarrer l’environnement de développement Ruby local comme suit :

1make start

Notez que cette commande ne démarre pas encore une application Ruby on Rails. Pour cela, nous devons ouvrir un shell dans l’environnement Docker et lui demander de démarrer le processus rails. Voici comment procéder :

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

Environnement Docker pour Ruby on Rails destiné au développement localEnfin, ouvrez votre navigateur et rendez-vous à cette URL : http://foo_bar_project.localhost/. Vous devriez voir le projet Ruby on Rails que nous venons de créer.

Alors, qu’avons-nous à notre disposition ?

• Notre projet contient un répertoire d’environnement qui regroupe tout le nécessaire à son exécution, ainsi qu’un répertoire d’application contenant le code de celle-ci. Ce répertoire est associé au conteneur Docker : vous y avez donc un accès complet depuis l’image Docker Ruby.

• Nous avons rapidement accès au shell Ruby. Il n’est donc pas nécessaire d’installer localement un environnement Ruby, comme Rails, Rake, Bundler ou tout autre outil de l’écosystème Ruby.

• Les commandes peuvent être exécutées après la commande make shell.

• Cette configuration Docker Compose du projet comprend deux environnements préconfigurés. Si vous devez déployer votre application Ruby quelque part, vous pouvez créer votre propre environnement. Rien de plus simple !

Si vous souhaitez comprendre le fonctionnement de l’environnement Docker pour Ruby on Rails présenté ci-dessus, nous allons détailler l’image Docker Ruby, le Makefile et la configuration Docker Compose qui les fait fonctionner ensemble.

Une image Docker Ruby

Tout d’abord, l’image Docker Ruby est un élément essentiel. Il est également important de la créer correctement afin de réutiliser efficacement le cache des couches d’image Docker et de prendre en compte d’autres aspects liés à un environnement de développement local.

Voici le Dockerfile de l’image Docker Ruby :

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"]

Comme vous pouvez le voir, cette configuration part du principe que certains paramètres périphériques sont définis pour disposer d’un environnement Ruby on Rails fonctionnel, notamment :

• le fichier database.yml, prérempli avec les détails de connexion à la base de données Ruby on Rails

• le fichier development.rb, qui contient la configuration de l’environnement d’exécution Ruby on Rails pour le développement

Ces paramètres sont définis à l’aide du script runners.sh, dans le répertoire ./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

Ce Dockerfile utilise également les builds Docker multiétapes. Vous pouvez ainsi réutiliser efficacement certaines parties dans différents environnements, si vous souhaitez utiliser la même configuration pour plusieurs workflows (tests, préproduction, etc.).

Docker Compose pour Rails

Le fichier Docker Compose situé dans `./environment/docker-compose.development.yml` rassemble tous les services nécessaires au fonctionnement d’une application Ruby on Rails dans Docker :

• un serveur HTTP nginx

• une application Ruby

• un serveur de base de données PostgreSQL

Voici le fichier Docker Compose pour Rails utilisé dans cette configuration :

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 pour Docker

Enfin, pour fournir aux développeurs une interface simple leur permettant d’interagir facilement avec cet environnement de développement local Ruby, nous utilisons 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

Exécuter efficacement des applications Ruby

J’espère que vous avez désormais acquis une nouvelle compétence : exécuter des applications Ruby, comme Ruby on Rails, dans votre environnement local à l’aide d’une configuration de conteneurs Docker. Une autre façon d’exécuter des applications Ruby en local consiste à utiliser des environnements virtuels Ruby, que nous avons présentés dans notre précédent article sur l’installation de Ruby sur macOS.

Maintenant que votre environnement de développement Ruby est prêt, vous voudrez peut-être aussi apprendre à sécuriser vos applications Ruby. Consultez les articles suivants pour en savoir plus sur la sécurité de Ruby :

• Analyser les gems Ruby avec Snyk

• Le guide complet de la gestion des dépendances des gems Ruby