API REST avec Rails

Pourquoi API REST avec Rails ?

L'API REST (Representational State Transfer) est un ensemble de conventions et de pratiques pour construire des services Web qui permettent aux différents systèmes de communiquer entre eux. En tant que développeur Rails, vous aurez souvent besoin d'exposer certaines fonctionnalités de votre application sous forme d'API, afin de permettre l'interaction avec d'autres applications ou services.

Un cas d'utilisation concret serait une application de gestion de projet qui a besoin de s'intégrer avec un système de gestion des tâches externes. L'API REST vous permettrait d'exposer les fonctionnalités de création, lecture, mise à jour et suppression (CRUD) des tâches au sein de votre application.

Prerequis

• Connaissance approfondie du langage Ruby
• Familiarité avec le framework Rails
• Compréhension des concepts fondamentaux de l'API REST (GET, POST, PUT, DELETE)
• Installation d'un environnement de développement Rails (Ruby, Bundler, etc.)

Concepts fondamentaux

1. Contrôleur (Controller)

Un contrôleur dans Rails gère les requêtes HTTP et renvoie des réponses au format demandé (JSON, XML, HTML). Chaque action du contrôleur correspond à une route spécifique.

## app/controllers/tasks_controller.rb
class TasksController < ApplicationController
  # GET /tasks
  def index
    @tasks = Task.all
    render json: @tasks
  end

  # GET /tasks/1
  def show
    @task = Task.find(params[:id])
    render json: @task
  end

  # POST /tasks
  def create
    @task = Task.new(task_params)
    if @task.save
      render json: @task, status: :created, location: @task
    else
      render json: @task.errors, status: :unprocessable_entity
    end
  end

  # PATCH/PUT /tasks/1
  def update
    @task = Task.find(params[:id])
    if @task.update(task_params)
      render json: @task
    else
      render json: @task.errors, status: :unprocessable_entity
    end
  end

  # DELETE /tasks/1
  def destroy
    @task.destroy
  end

  private

  # Only allow a list of trusted parameters through.
  def task_params
    params.require(:task).permit(:name, :description)
  end
end

2. Modèle (Model)

Le modèle dans Rails est responsable de la logique métier et de l'interaction avec la base de données.

## app/models/task.rb
class Task < ApplicationRecord
  # Validation pour s'assurer que le nom n'est pas vide
  validates :name, presence: true
end

3. Route (Route)

Les routes définissent comment les URL sont mappées aux actions du contrôleur.

## config/routes.rb
Rails.application.routes.draw do
  resources :tasks
end

4. Paramètres de la requête (Request Parameters)

Les paramètres de la requête permettent d'envoyer des données à l'action du contrôleur.

def create
  @task = Task.new(task_params)
  if @task.save
    render json: @task, status: :created, location: @task
  else
    render json: @task.errors, status: :unprocessable_entity
  end
end

private

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

5. Middleware (Middleware)

Les middleware sont des composants qui interceptent les requêtes HTTP avant qu'elles ne atteignent le contrôleur.

## app/middleware/authorization.rb
class Authorization
  def initialize(app)
    @app = app
  end

  def call(env)
    if env['HTTP_AUTHORIZATION'].present?
      @app.call(env)
    else
      [401, { 'Content-Type' => 'text/plain' }, ['Unauthorized']]
    end
  end
end

Ensuite, ajoutez le middleware dans la configuration de Rails :

## config/application.rb
module MyApp
  class Application < Rails::Application
    config.middleware.use Authorization
  end
end

Mise en pratique : projet fil rouge

Étape 1 : Création du nouveau projet

rails new task_manager_api --api
cd task_manager_api

Étape 2 : Génération des modèles et migrations

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

Étape 3 : Création du contrôleur

rails generate controller Tasks --api

Ajoutez les actions CRUD au contrôleur app/controllers/tasks_controller.rb comme mentionné dans la section "Concepts fondamentaux".

Étape 4 : Configuration des routes

Mettez à jour le fichier de routes config/routes.rb :

Rails.application.routes.draw do
  resources :tasks, only: [:index, :show, :create, :update, :destroy]
end

Étape 5 : Exécution du serveur

Lancez le serveur Rails :

rails server

Vous devriez maintenant être en mesure de tester votre API à travers les endpoints suivants :

• GET /tasks
• GET /tasks/:id
• POST /tasks
• PUT /tasks/:id
• DELETE /tasks/:id

Erreurs frequentes et debugging

1. undefined method 'permit' for nil:NilClass

## ❌ Mauvais
def task_params
  params.require(:task).permit(:name, :description)
end
ruby
## ✅ Correct
def task_params
  if params[:task].present?
    params.require(:task).permit(:name, :description)
  else
    {}
  end
end

2. ActiveRecord::RecordInvalid: Validation failed

## ❌ Mauvais
@task = Task.new(task_params)
if @task.save!
  render json: @task, status: :created, location: @task
else
  render json: @task.errors, status: :unprocessable_entity
end
ruby
## ✅ Correct
@task = Task.new(task_params)
if @task.save
  render json: @task, status: :created, location: @task
else
  render json: @task.errors, status: :unprocessable_entity
end

3. No route matches [GET] "/tasks"

## ❌ Mauvais
Rails.application.routes.draw do
  get 'tasks', to: 'tasks#index'
end
ruby
## ✅ Correct
Rails.application.routes.draw do
  resources :tasks, only: [:index, :show, :create, :update, :destroy]
end

Pour aller plus loin

1. Gestion des erreurs et exceptions : Explorez comment gérer les exceptions dans Rails pour une meilleure robustesse de votre API.

   • Rails Guides: Exception Handling

2. Documentation de l'API : Utilisez Swagger ou RDoc pour générer la documentation de votre API, facilitant ainsi le développement et la maintenance.

   • Swagger for Rails
   • RDoc

3. Authentification et autorisation : Ajoutez des mécanismes d'authentification comme JWT (JSON Web Tokens) pour sécuriser vos API.

   • Devise for JWT Authentication

Défi pratique : Implémentez une fonctionnalité de pagination dans votre API afin de gérer efficacement les grands ensembles de données.