HowtoForge

Tutoriels Linux

Configurer l’environnement de développement Ruby on Rails avec Docker et Docker Compose sur Ubuntu

Docker est un projet open-source qui fournit une plateforme ouverte aux développeurs et aux sysadmins pour construire, empaqueter et exécuter des applications n’importe où sous forme de conteneur léger. Docker automatise le déploiement d’applications à l’intérieur de conteneurs logiciels.

Ruby on Rails (RoR) est un cadre d’application Web open source, publié sous la licence MIT. C’est un cadre d’application Web côté serveur qui suit le concept MVC (Model-View-Controller).

Dans ce tutoriel, je vais te montrer comment configurer un environnement de développement pour les applications Ruby on Rails à l’aide de Docker et de Docker compose. Nous utiliserons Ubuntu 18.04 comme système d’exploitation hôte et utiliserons la base de données PostgreSQL pour notre projet Rails.

Ce que nous allons faire :

  1. Installer Docker et Docker Compose
  2. Générer le projet Rails
  3. Configurer le projet Rails
  4. Créer le script Docker Compose
  5. Construis le projet
  6. Teste la création de CRUD de base sur Rails

Étape 1 – Installer Docker et Docker Compose

La première étape que nous devons faire est d’installer le docker et le docker compose lui-même. Nous allons installer le docker à partir du dépôt officiel de docker, et installer le docker-compose à partir du projet officiel de docker sur GitHub.

Avant d’installer les paquets Docker, exécute la commande apt ci-dessous pour installer les dépendances des paquets.

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

Ajoute maintenant la clé docker et le dépôt 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"

La commande mettra automatiquement à jour tous les référentiels sur le système. Quand elle est terminée, installe les paquets docker-ce.

sudo apt install -y docker-ce

Attends l’installation de docker-ce, puis démarre le service docker et ajoute-le au temps de démarrage.

sudo systemctl start docker
 sudo systemctl enable docker

Le Docker est en place et fonctionne sur le système.

Ensuite, installe le docker-compose en téléchargeant le fichier binaire directement depuis le dépôt GitHub de docker.

Télécharge le fichier binaire docker-compose dans le répertoire ‘/usr/local/bin/’ et fais-en un exécutable.

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

Le docker et le docker-compose ont été installés sur le système, vérifie la version à l’aide des commandes ci-dessous.

docker version
 docker-compose version

Voici le résultat.

Installer Docker

Étape 2 – Générer le projet Ruby on Rails

Après avoir installé les paquets de base docker et docker-compose sur le système, nous voulons créer un nouvel utilisateur, puis générer le projet Rails à l’aide des images docker.

Ajoute un utilisateur nommé ‘hakase’ et donne-lui un mot de passe.

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

Ajoute l’utilisateur au groupe ‘sudo’ et ‘docker’ et connecte-toi au shell de l’utilisateur ‘hakase’.

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

Maintenant, l’utilisateur ‘hakase’ peut exécuter et lancer la commande docker.

Ensuite, nous allons créer un nouveau répertoire ‘rails’ pour notre projet Ruby on Rails.

Crée le répertoire ‘rails’ et ouvre-le.

mkdir -p ~/rails
 cd ~/rails/

Exécute maintenant la commande ‘docker run’ ci-dessous.

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

La commande exécutera le conteneur temporaire basé sur l’image ruby:alpine, montera le répertoire local dans le répertoire ‘/usr/src’ à l’intérieur du conteneur, puis exécutera la commande shell ‘sh’ et ira dans le répertoire ‘app’.

Génère un projet Ruby on Rails

Dans le conteneur, installe les paquets ‘build-base’.

apk add build-base

Installe maintenant Ruby on Rails dans le conteneur temporaire.

gem install -N rails

Et génère le nouveau projet Rails nommé ‘app’ avec PostgreSQL comme base de données, puis quitte/se déconnecte du conteneur.

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

Tu te trouveras dans le répertoire du projet Rails ‘app’.

Change maintenant le propriétaire du répertoire de projet ‘app’ pour l’utilisateur ‘hakase’.

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

Et le projet Ruby on Rails a été généré par le conteneur docker temporaire.

Projet Rails

Étape 3 – Configurer le projet Rails

Dans cette étape, nous allons créer un nouveau Dockerfile pour nos applications Rails.

Dans le répertoire ‘rails’, crée un nouveau Dockerfile à l’aide de vim.

vim Dockerfile

Colle la configuration ci-dessous.

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

Sauvegarde et quitte.

Nous créons une nouvelle image Docker basée sur le linux Ruby Alpine. Nous installons de nouveaux paquets pour l’installation de rails, crée un nouveau répertoire /app, copie le Gemfile et Gemfile.lock du répertoire local app, et installe tous les paquets basés sur le Gemfile.

Ensuite, va dans le répertoire ‘app’ et crée un nouveau fichier Gemfile.lock.

cd app/
 touch Gemfile.lock

Modifie le fichier ‘database.yml’.

vim config/database.yml

Change la configuration de la base de données par défaut et modifie les détails comme ci-dessous.

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

Sauvegarde et quitte.

Configure le projet Rails

La configuration du projet Rails est terminée.

Étape 4 – Créer le fichier Docker Compose

Dans cette étape, nous allons créer un nouveau fichier docker-compose pour notre application Rails. Nous ne créerons que deux services : db database PostgreSQL et web est l’application Rails elle-même.

Crée un nouveau fichier ‘docker-compose.yml’ dans le répertoire ‘rails’.

vim docker-compose.yml

Et colle la configuration ci-dessous.

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

Sauvegarde et quitte.

Créer le fichier Docker Compose

Crée maintenant le répertoire ‘postgresql’ dans le projet ‘rails’.

mkdir -p ~/rails/postgresql

Et nous sommes prêts à construire notre projet Rails.

Étape 5 – Construis le projet

Construis l’image docker Rails à l’aide de la commande docker-compose ci-dessous.

docker-compose build

La commande téléchargera l’image Ruby Alpine Linux et construira l’image personnalisée dont nous avons besoin en fonction de notre Dockerfile.

Construis le projet

Génère la base de données PostgreSQL pour le projet.

docker-compose run web rake db:create

Docker compose run

Mets maintenant en place les services ‘db’ et ‘web’.

docker-compose up -d

Les services rails sont en place et fonctionnent, vérifie-les à l’aide de la commande docker-compose ci-dessous.

docker-compose ps

Tu peux voir que le service ‘web’ fonctionne sur le port ’80’ sur l’hôte.

Vérifie maintenant les images docker sur notre système.

docker-compose images

Et tu obtiendras le résultat ci-dessous.

Images de composition Docker

Ouvre maintenant ton navigateur Web et tape l’adresse IP ou le nom de domaine du serveur. Le mien est :

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

Et tu obtiendras l’application de page Rails par défaut sur ce serveur.

Rails s'exécute avec succès

Maintenant, nous sommes prêts à développer notre projet Rails.

Étape 6 – Teste la création de CRUD de base sur Rails

Crée un CRUD simple sur Rails en exécutant la commande Rails dans le service du conteneur ‘web’.

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

Génère maintenant la base de données.

docker-compose exec web rake db:migrate

Test Create Basic CRUD on Rails

Ouvre maintenant ton navigateur Web et tape l’adresse IP du serveur dans la barre d’adresse avec le chemin ‘/posts’. La mienne est :

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

Et tu obtiendras la page CRUD simple comme ci-dessous.

Test POST form

Tape le message et clique sur le bouton ‘Create Post’.

Et tu obtiendras le résultat ci-dessous.

L'application Rails fonctionne correctement

La configuration de l’environnement de développement pour Ruby on Rails avec Docker et Docker Compose a été effectuée avec succès.

Référence

Vous aimerez aussi...