Skip to content
Learni
View all tutorials
Développement Backend

Comment créer une API REST avec Ruby on Rails en 2026

18 minINTERMEDIATE
API RESTRuby on Rails

Introduction

Ruby on Rails reste en 2026 un framework de référence pour créer rapidement des APIs REST performantes. Ce tutoriel intermédiaire vous guide dans la construction d'une API complète de gestion de tâches. Vous apprendrez à structurer vos modèles Active Record, à exposer des endpoints JSON sécurisés et à implémenter des tests robustes. L'approche met l'accent sur les bonnes pratiques modernes : sérialisation avec JSON:API, validation côté serveur et gestion des erreurs standardisée. Ce guide est conçu pour les développeurs ayant déjà des bases Rails et souhaitant passer à un niveau professionnel.

Prérequis

  • Ruby 3.3+ et Rails 8.0+
  • Connaissances de base en Active Record et MVC
  • PostgreSQL installé
  • Outil de test comme RSpec ou Minitest

Initialisation du projet

terminal
rails new task_api --api -d postgresql
cd task_api
rails db:create

La commande --api génère une structure allégée sans vues. PostgreSQL est utilisé pour sa fiabilité avec les migrations Rails. Exécutez cette commande dans un terminal propre.

Création du modèle Task

app/models/task.rb
class Task < ApplicationRecord
  validates :title, presence: true, length: { minimum: 3 }
  validates :status, inclusion: { in: %w[todo in_progress done] }
  enum :status, { todo: 0, in_progress: 1, done: 2 }
end

Le modèle inclut des validations strictes et un enum pour le statut. Cela garantit l'intégrité des données dès la couche modèle avant d'atteindre le contrôleur.

Migration associée

db/migrate/20260115120000_create_tasks.rb
class CreateTasks < ActiveRecord::Migration[8.0]
  def change
    create_table :tasks do |t|
      t.string :title, null: false
      t.text :description
      t.integer :status, default: 0, null: false
      t.timestamps
    end
    add_index :tasks, :status
  end
end

La migration crée la table avec un index sur status pour optimiser les requêtes de filtrage. Exécutez rails db:migrate ensuite.

Contrôleur Tasks

app/controllers/tasks_controller.rb
class TasksController < ApplicationController
  before_action :set_task, only: [:show, :update, :destroy]

  def index
    @tasks = Task.all
    render json: @tasks
  end

  def show
    render json: @task
  end

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

  private

  def set_task
    @task = Task.find(params[:id])
  end

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

Le contrôleur gère les opérations CRUD standards avec gestion d'erreurs HTTP appropriées. before_action factorise la recherche du record.

Configuration des routes

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

Les routes RESTful sont limitées aux actions nécessaires. Cela expose uniquement les endpoints de l'API sans routes superflues.

Tests avec Minitest

test/controllers/tasks_controller_test.rb
require 'test_helper'

class TasksControllerTest < ActionDispatch::IntegrationTest
  test 'should get index' do
    get tasks_url
    assert_response :success
    assert_not_nil JSON.parse(response.body)
  end

  test 'should create task' do
    assert_difference('Task.count') do
      post tasks_url, params: { task: { title: 'Test task', status: 'todo' } }
    end
    assert_response :created
  end
end

Les tests couvrent les endpoints principaux et valident les codes de statut. Exécutez rails test pour vérifier le bon fonctionnement.

Bonnes pratiques

  • Toujours utiliser des validations dans les modèles
  • Limiter les paramètres avec strong parameters
  • Retourner des codes HTTP sémantiques (201, 422, 404)
  • Versionner l'API dès que possible (/api/v1)
  • Ajouter de la pagination pour les collections importantes

Erreurs courantes à éviter

  • Oublier les validations côté modèle et autoriser des données invalides
  • Exposer des attributs sensibles sans sérializer
  • Ne pas gérer les exceptions ActiveRecord::RecordNotFound
  • Ignorer les tests d'intégration des endpoints

Pour aller plus loin

Approfondissez la sérialisation avancée avec fast_jsonapi ou jsonapi-serializer. Découvrez nos formations Rails avancées.