Docker Compose : Rails + PostgreSQL

Pourquoi Docker Compose : Rails + PostgreSQL ?

Le développement d'applications web modernes implique souvent la manipulation de plusieurs services, comme un serveur web (comme Nginx ou Puma), une base de données relationnelle (comme PostgreSQL) et des microservices (comme Redis). Utiliser Docker est une excellente façon de containeriser ces composants pour créer une environnement cohérent et portable. Cependant, gérer les dépendances et les configurations manuellement peut être fastidieux et source d'erreurs. C'est là que Docker Compose entre en jeu.

Docker Compose est un outil qui permet de définir et de lancer des applications multi-conteneur à partir d'un seul fichier YAML. En utilisant Docker Compose, vous pouvez décrire toutes les configurations nécessaires pour chaque service (Rails app, PostgreSQL, Redis, etc.) dans un seul fichier et lancer tous ces services en une seule commande.

Un cas concret de l'utilisation de Docker Compose est lorsqu'on travaille sur un projet qui nécessite une base de données relationnelle. L'installation manuelle de PostgreSQL peut être complexe et varie selon le système d'exploitation. En utilisant Docker Compose, on peut configurer et démarrer une instance de PostgreSQL dans un conteneur Docker en quelques minutes.

Prerequis

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

• Ruby : version 3.x (vous pouvez utiliser rbenv ou rvm pour gérer les versions)
• Rails : version 7.x
• Docker : version 20.10.7 ou plus récente
• Docker Compose : version 1.29.2 ou plus récente

Installation des outils

Ruby et Rails

## Installer rbenv pour gérer les versions de Ruby
curl -fsSL https://github.com/rbenv/rbenv-installer/raw/HEAD/bin/install.sh | bash

## Ajoutez rbenv à votre PATH
echo 'export PATH="$HOME/.rbenv/bin:$PATH"' >> ~/.bashrc
source ~/.bashrc

## Installer la version de Ruby requise pour Rails 7.x (par exemple, ruby-3.2.0)
rbenv install 3.2.0
rbenv global 3.2.0

## Installer Rails
gem install rails -v 7.0.6.1

Docker et Docker Compose

## Installer Docker
sudo apt-get update
sudo apt-get install docker.io

## Ajoutez votre utilisateur au groupe Docker
sudo usermod -aG docker $USER
newgrp docker

## Installer Docker Compose
sudo curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose

Concepts fondamentaux

Dockerfile

Un Dockerfile est un fichier texte qui contient des instructions pour construire une image Docker. Voici un exemple de Dockerfile pour une application Rails :

## Utilisez une image officielle de Ruby comme base
FROM ruby:3.2.0

## Set working directory in the container
WORKDIR /app

## Copy Gemfile and Gemfile.lock
COPY Gemfile Gemfile.lock ./

## Install dependencies
RUN bundle install --jobs 4 --retry 5

## Copy application code
COPY . .

## Precompile assets (only needed for production)
CMD ["rails", "server", "-b", "0.0.0.0"]

docker-compose.yml

Le fichier docker-compose.yml définit les services, les réseaux et les volumes pour votre application. Voici un exemple de configuration pour une Rails app avec PostgreSQL :

version: '3.8'

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

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

volumes:
  db_data:

Mise en pratique : projet fil rouge

Nous allons créer un simple application Rails pour gérer des tâches. Cette application inclura un modèle Task et une interface utilisateur pour ajouter et afficher les tâches.

Étape 1 : Initialisation du projet Rails

rails new task_manager --database=postgresql
cd task_manager

Étape 2 : Configuration de Dockerfile

Créez un fichier Dockerfile dans le répertoire racine du projet avec le contenu suivant :

FROM ruby:3.2.0

WORKDIR /app

COPY Gemfile Gemfile.lock ./

RUN bundle install --jobs 4 --retry 5

COPY . .

CMD ["rails", "server", "-b", "0.0.0.0"]

Étape 3 : Configuration de docker-compose.yml

Créez un fichier docker-compose.yml dans le répertoire racine du projet avec le contenu suivant :

version: '3.8'

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

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

volumes:
  db_data:

Étape 4 : Création de la migration et du modèle

rails generate model Task title:string description:text completed:boolean
rails db:migrate

Étape 5 : Création des contrôleurs et des vues

Créez un contrôleur TasksController :

class TasksController < ApplicationController
  def index
    @tasks = Task.all
  end

  def new
    @task = Task.new
  end

  def create
    @task = Task.create(task_params)
    if @task.save
      redirect_to tasks_path
    else
      render :new
    end
  end

  private

  def task_params
    params.require(:task).permit(:title, :description, :completed)
  end
end

Créez les vues pour index et new :

app/views/tasks/index.html.erb

<h1>Tasks</h1>
<%= form_with url: tasks_path do |form| %>
  <%= form.text_field :title, placeholder: 'Title' %>
  <%= form.text_area :description, placeholder: 'Description' %>
  <%= form.check_box :completed, label: 'Completed?' %>
  <%= form.submit 'Create Task' %>
<% end %>

<ul>
  <% @tasks.each do |task| %>
    <li><%= task.title %> - <%= task.description %> - <%= task.completed ? 'Completed' : 'Pending' %></li>
  <% end %>
</ul>

app/views/tasks/new.html.erb

<h1>Create Task</h1>

<%= form_with url: tasks_path do |form| %>
  <%= form.text_field :title, placeholder: 'Title' %>
  <%= form.text_area :description, placeholder: 'Description' %>
  <%= form.check_box :completed, label: 'Completed?' %>
  <%= form.submit 'Create Task' %>
<% end %>

Étape 6 : Lancement de l'application

docker-compose up --build

Ouvrez votre navigateur et allez à http://localhost:3000. Vous devriez voir une application Rails avec la possibilité d'ajouter et de visualiser des tâches.

Erreurs frequentes et debugging

Erreur 1 : Le serveur ne démarre pas

Code incorrect :

docker-compose up --build

Code correct :

docker-compose up --force-recreate --build

Erreur 2 : Base de données non trouvée

Code incorrect :

class Task < ApplicationRecord
end

Code correct :

class Task < ApplicationRecord
  self.table_name = 'tasks'
end

Erreur 3 : Mauvais chemin pour le fichier d'application

Code incorrect :

rails server -b 0.0.0.0

Code correct :

docker-compose run web rails server -b 0.0.0.0

Pour aller plus loin

1. Utiliser des environnements de développement séparés pour chaque service : En utilisant Docker Compose, vous pouvez facilement configurer des environnements de développement séparés pour chaque service. Cela permet d'isoler les dépendances et facilite le travail en équipe.

2. Optimiser l'utilisation des ressources avec Docker Compose : Vous pouvez utiliser des fonctionnalités comme cgroups et limits pour limiter la consommation de ressources par les conteneurs. Cela peut aider à éviter les problèmes de performance sur votre système.

3. Ajouter des tests à votre application : En utilisant Docker Compose, vous pouvez facilement ajouter des tests à votre application. Par exemple, vous pouvez utiliser le service web pour exécuter des tests RSpec ou des tests d'intégration.

Défi pratique

Développez une API de blog simple en utilisant Docker Compose. Cette API devra permettre aux utilisateurs de créer et de récupérer des articles. Utilisez un modèle Article, un contrôleur ArticlesController et une base de données PostgreSQL.

Bon appétit !