Skip to content
Learni
Voir tous les tutoriels
Backend

Comment développer une API avec Ruby on Rails en 2026

18 minINTERMEDIATE
APIRubyRails
Read in English

Introduction

Ruby on Rails reste en 2026 un framework de référence pour les APIs RESTful rapides et maintenables. Sa convention over configuration permet de livrer des fonctionnalités en quelques heures plutôt qu'en jours. Ce tutoriel intermédiaire vous guide dans la création d'une API de gestion d'articles avec authentification par token, validations et sérialisation JSON. Vous apprendrez à structurer un projet Rails API-only, à utiliser Active Model Serializers et à écrire des tests robustes avec RSpec. Chaque étape inclut du code complet et exécutable.

Prérequis

  • Ruby 3.3+ et Rails 8.0+
  • Connaissances de base en Ruby et REST
  • PostgreSQL installé
  • Outil de test API (Postman ou curl)

Initialiser le projet API

terminal
rails new blog_api --api -d postgresql
cd blog_api
bundle install
rails db:create

L'option --api génère une structure allégée sans vues. PostgreSQL est utilisé pour la production. La commande db:create prépare la base de données immédiatement.

Configuration de l'API

Nous allons maintenant ajouter Active Model Serializers et configurer CORS pour autoriser les requêtes depuis le frontend.

Ajouter les gems nécessaires

Gemfile
gem 'active_model_serializers', '~> 0.10.14'
gem 'rack-cors'
gem 'bcrypt'
group :development, :test do
  gem 'rspec-rails'
end

Active Model Serializers gère la sérialisation JSON propre. rack-cors permet les requêtes cross-origin. bcrypt est requis pour le hachage des tokens.

Créer le modèle Article

app/models/article.rb
class Article < ApplicationRecord
  validates :title, :content, presence: true
  validates :title, length: { minimum: 3, maximum: 100 }
end

Le modèle inclut des validations strictes. Ces règles sont automatiquement appliquées avant toute sauvegarde en base.

Générer le contrôleur API

app/controllers/api/v1/articles_controller.rb
module Api
  module V1
    class ArticlesController < ApplicationController
      def index
        articles = Article.all
        render json: articles, each_serializer: ArticleSerializer
      end

      def create
        article = Article.new(article_params)
        if article.save
          render json: article, serializer: ArticleSerializer, status: :created
        else
          render json: { errors: article.errors }, status: :unprocessable_entity
        end
      end

      private

      def article_params
        params.require(:article).permit(:title, :content)
      end
    end
  end
end

Le contrôleur respecte les conventions REST. Les erreurs de validation sont renvoyées avec le bon code HTTP 422.

Définir les routes API

config/routes.rb
Rails.application.routes.draw do
  namespace :api do
    namespace :v1 do
      resources :articles, only: [:index, :create, :show]
    end
  end
end

Le namespace v1 permet une versioning propre de l'API. Seules les actions nécessaires sont exposées.

Créer le serializer

app/serializers/article_serializer.rb
class ArticleSerializer < ActiveModel::Serializer
  attributes :id, :title, :content, :created_at
end

Le serializer contrôle exactement les champs exposés et évite les fuites de données sensibles.

Bonnes pratiques

  • Versionnez toujours votre API avec des namespaces
  • Utilisez des serializers pour contrôler les données exposées
  • Validez les paramètres avec strong parameters
  • Écrivez des tests RSpec pour chaque endpoint
  • Activez la journalisation des requêtes en production

Erreurs courantes

  • Oublier de configurer CORS (erreurs cross-origin)
  • Exposer tous les attributs du modèle sans serializer
  • Ne pas gérer les erreurs de validation côté client
  • Utiliser des routes non versionnées

Pour aller plus loin

Découvrez nos formations avancées Ruby on Rails pour maîtriser l'authentification JWT, les jobs Sidekiq et le déploiement sur Kubernetes.