Deployer Rails avec Docker

Deployer Rails avec Docker : Tutoriel approfondi pour les développeurs intermédiaires

Pourquoi Deployer Rails avec Docker ?

La déclaration de Docker est devenue une pratique standard dans le développement moderne, notamment pour les applications Ruby on Rails. Elle offre un environnement de développement cohérent et répétable partout, ce qui réduit les problèmes liés aux différences entre les environnements locaux et de production. En outre, Docker permet d'optimiser la performance et la sécurité de vos applications en isolant les dépendances du système hôte.

Un cas d'utilisation concret est le déploiement continu (CI/CD) des projets Rails. Les développeurs peuvent utiliser Docker pour créer une image qui capturent l'environnement de développement complet, y compris toutes les dépendances nécessaires. Cela permet aux équipes de travailler sur la même configuration et d'être confiants dans le déploiement continu sans risque de problèmes liés aux différences entre les environnements.

Prerequis

Pour suivre ce tutoriel, vous aurez besoin des éléments suivants :

• Ruby 2.7.x (ou plus tard)
• Rails 6.1.x (ou plus tard)
• Docker 20.10.x (ou plus tard)
• Docker Compose 1.29.x (ou plus tard)
• Un compte GitHub (facultatif, pour stocker et partager votre code)

Concepts fondamentaux

1. Dockerfile

Le Dockerfile est un fichier texte qui contient toutes les instructions nécessaires pour construire une image Docker. Cette image peut ensuite être utilisée pour exécuter un conteneur.

## 📄 Dockerfile
FROM ruby:2.7-slim

## Installer les dépendances système
RUN apt-get update && apt-get install -y build-essential libpq-dev nodejs

## Créer le répertoire de l'application
WORKDIR /app

## Copier les fichiers Gemfile et Gemfile.lock
COPY Gemfile Gemfile.lock ./

## Installer les gems
RUN bundle install

## Copier le reste des fichiers de l'application
COPY . .

## Exécuter la commande d'initialisation de l'application (ex: rails db:migrate)
CMD ["rails", "server", "-b", "0.0.0.0"]

2. docker-compose.yml

Le docker-compose.yml est un fichier qui définit et configure les services, les réseaux et les volumes pour une application Docker.

## 📄 docker-compose.yml
version: '3.8'

services:
  web:
    build: .
    command: rails s -p 3000 -b '0.0.0.0'
    volumes:
      - .:/app
    ports:
      - "3000:3000"
    depends_on:
      - db

  db:
    image: postgres:12
    environment:
      POSTGRES_DB: myapp_development
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
    volumes:
      - db_data:/var/lib/postgresql/data

volumes:
  db_data:

3. .dockerignore

Le .dockerignore est un fichier qui spécifie les fichiers et les dossiers à exclure lors de la construction de l'image Docker.

## 📄 .dockerignore
node_modules
log
tmp
db
vendor/bundle
.env

4. Configurations Rails pour Docker

Pour que votre application Rails fonctionne dans un environnement Docker, vous devez effectuer quelques ajustements :

• config/database.yml : Configurez la base de données PostgreSQL.

## 📄 config/database.yml
default: &default
  adapter: postgresql
  encoding: unicode
  pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
  username: user
  password: password

development:
  <<: *default
  database: myapp_development

• config/puma.rb : Configurez Puma pour fonctionner avec Docker.

## 📄 config/puma.rb
threads_count = ENV.fetch("RAILS_MAX_THREADS") { 5 }
threads threads_count, threads_count

preload_app!

rackup DefaultRackup
port ENV.fetch("PORT") { 3000 }

environment ENV.fetch("RAILS_ENV") { "development" }

pidfile ENV.fetch("PIDFILE") { "tmp/pids/server.pid" }

Mise en pratique : projet fil rouge

Étape 1 : Créer un nouveau projet Rails

## 📄 Terminal
rails new myapp --database=postgresql
cd myapp

Étape 2 : Ajouter les dépendances nécessaires

Modifier le Gemfile pour ajouter des gems utiles :

## 📄 Gemfile
gem 'devise'
gem 'puma'
gem 'pg'
gem 'redis'

Exécuter la commande suivante pour installer les gems :

## 📄 Terminal
bundle install

Étape 3 : Configurer Devise

Générer un modèle utilisateur avec Devise :

## 📄 Terminal
rails generate devise User
rails db:migrate

Étape 4 : Créer une application simple

Créez une simple page d'accueil :

<!-- 📄 app/views/home/index.html.erb -->
<h1>Bienvenue sur mon application Rails avec Docker</h1>
<p><%= link_to 'Se connecter', new_user_session_path %></p>

Ajoutez une route pour la page d'accueil :

## 📄 config/routes.rb
Rails.application.routes.draw do
  devise_for :users
  root to: 'home#index'
end

Étape 5 : Configurer Docker

Créer un Dockerfile et un docker-compose.yml comme décrit ci-dessus.

Étape 6 : Construire et exécuter l'image Docker

Construire l'image Docker :

## 📄 Terminal
docker-compose build

Exécuter les conteneurs :

## 📄 Terminal
docker-compose up

Accéder à votre application via http://localhost:3000.

Erreurs frequentes et debugging

1. Error : Could not find the file 'Gemfile'

Cause :

## ❌ Mauvais
bundle install

Correction :

## ✅ Correct
cp .env.example .env
bundle install

2. Error : PG::ConnectionBad: could not connect to server

Cause :

## ❌ Mauvais
rails db:create

Correction :

## ✅ Correct
docker-compose run web rails db:create

3. Error : Could not find file 'config/database.yml'

Cause :

## ❌ Mauvais
rails server

Correction :

## ✅ Correct
## config/database.yml
default: &default
  adapter: postgresql
  encoding: unicode
  pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
  username: user
  password: password

development:
  <<: *default
  database: myapp_development

Pour aller plus loin

1. Utiliser Docker Secrets pour les variables d'environnement sensibles

https://docs.docker.com/engine/swarm/secrets/

2. Optimiser l'image Docker avec multi-stage builds

https://docs.docker.com/build/building/multi-stage/

3. Intégrer des tests dans votre pipeline CI/CD

https://circleci.com/docs/configuring-tests/

Défi pratique : Créer une application de gestionnaire de tâches

Construire une petite application Rails qui permet d'ajouter, modifier et supprimer des tâches. Assurez-vous de suivre les étapes du tutoriel pour créer un environnement Docker complet.

Ce tutoriel a couvert les concepts fondamentaux de déploiement Ruby on Rails avec Docker, ainsi qu'une mise en pratique complète d'un mini-projet réel. En suivant ces instructions, vous devriez être capable de déployer votre application Rails dans un environnement Docker cohérent et répétable. N'oubliez pas de tester votre application localement avant de la déployer en production pour s'assurer qu'elle fonctionne correctement.