Sinatra, la façon la plus simple de créer une API RESTful en Ruby

Écrit par Matteo G.

Récemment, j’ai découvert ce qui, selon moi, est la solution la plus simple pour créer une API RESTful en Ruby: Sinatra ! C’est un framework web minimaliste écrit en Ruby qui permet de créer des applications web, des APIs RESTful et des services web de façon simple et rapide.

Sinatra n’impose aucune structure particulière, ce qui le rend particulièrement adapté aux petits ou moyens projets.

C’est pourquoi dans cet article je vais vous montrer comment créer une API RESTful en Ruby en faisant un CRUD complet grâce à Sinatra.

Architecture

Comme dit précédemment, Sinatra ne force pas une structure particulière, c’est pourquoi ici on va opter pour une architecture la plus simple possible.

API_SINATRA
  │_ app.rb
  │_ Gemfile
  │_ Gemfile.lock

C’est tout, ici on ne va avoir que trois fichiers, le fichier app.rb qui contiendra notre application, le fichier Gemfile qui contiendra les dépendances de notre application et le fichier Gemfile.lock qui contiendra les versions des dépendances.

Installation

Sinatra étant une gem Ruby, pour l’installer il nous suffit ici de l’ajouter dans notre Gemfile et de lancer la commande bundle install

# Gemfile
source "https://rubygems.org"

gem "sinatra"
gem "json"

J’ai également ajouté la gem json qui nous permettra de manipuler des objets JSON.

$ bundle install

Création de l’API

Une fois que la gem Sinatra est installée dans notre projet, on va pouvoir passer au code de notre API. On va donc se rendre dans notre fichier app.rb et commencer par importer les dépendances.

require 'sinatra'
require 'json'

Ensuite, je vais créer un tableau de hash qui va nous servir de base de données pour stocker nos articles. Nous pouvons également utiliser une base de données réelle ou un fichier JSON pour stocker nos données, mais pour rester dans un contexte de simplicité je vais juste utiliser un tableau de hash.

articles = [
  { id: 1, title: "Apprendre Sinatra", content: "C'est simple et rapide !" },
  { id: 2, title: "Avantage de Sinatra", content: "Sinatra est minimaliste." }
]

Maintenant qu’on a importé nos dépendances et créé quelques données dans un tableau, on va pouvoir commencer à créer nos requêtes.

Commençons par la méthode GET qui va nous permettre de récupérer tous les articles.

get '/articles' do
  content_type :json
  articles.to_json
end

Comme vous pouvez le voir ici, j’ai utilisé la méthode get de Sinatra pour créer une route qui va écouter les requêtes GET sur l’URL /articles. C’est dans cette méthode get que je vais pouvoir définir le métier de ma requête. Comme mon objectif ici était de récupérer tous mes articles, j’ai juste eu à retourner mon tableau d’articles en JSON.

Nous pouvons maintenant faire la même chose pour pouvoir récupérer un article en particulier.

get '/articles/:id' do
  article = articles.find { |a| a[:id] == params[:id].to_i }
  halt 404, { error: "Article non trouvé" }.to_json unless article
  content_type :json
  article.to_json
end

Donc tout simplement ici j’ai utilisé comme tout à l’heure la méthode get de Sinatra sauf que cette fois-ci j’ai changé mon URL pour lui dire de prendre un id en paramètre. Et dans mon job, pour récupérer l’item correspondant à mon article je vais passer par la méthode find de ruby en lui donnant mon paramètre id et retourner une erreur 404 si l’article n’existe pas ou à l’inverse renvoyer mon article en JSON si il existe.

Ensuite je vais vous montrer comment créer un article.

post '/articles' do
  new_article = JSON.parse(request.body.read, symbolize_names: true)
  new_article[:id] = articles.last[:id] + 1
  articles << new_article
  content_type :json
  status 201
  new_article.to_json
end

Pour pouvoir créer un article, on va devoir utiliser la méthode post de Sinatra. La différence ici, c’est qu’on va devoir récupérer les données du corps de la requête. On va donc utiliser request.body.read pour récupérer les données et JSON.parse pour les transformer en objet ruby. Ici j’indexe mes articles à la main car je n’ai pas de base de données ou de gem pour le faire automatiquement. Et pour finir, je rajoute mon article dans mon tableau et je retourne mon article en JSON.

Pour finir notre CRUD, il va nous manquer deux méthodes, la méthode put pour mettre à jour un article et la méthode delete pour supprimer un article.

put '/articles/:id' do
  article = articles.find { |a| a[:id] == params[:id].to_i }
  halt 404, { error: "Article non trouvé" }.to_json unless article

  updates = JSON.parse(request.body.read, symbolize_names: true)
  article.merge!(updates)
  content_type :json
  article.to_json
end

Pour pouvoir modifier un article, on va devoir utiliser la méthode put de Sinatra. Comme pour la méthode get, on va devoir récupérer l’article correspondant à l’id passé en paramètre. Et comme pour la méthode post, on va devoir récupérer les données du corps de la requête et les transformer en objet Ruby. Et une fois qu’on a trouvé notre article, on va pouvoir le mettre à jour avec les nouvelles données et le retourner en JSON.

Finissons par la méthode delete pour supprimer un article.

delete '/articles/:id' do
  article = articles.find { |a| a[:id] == params[:id].to_i }
  halt 404, { error: "Article non trouvé" }.to_json unless article

  articles.delete(article)
  content_type :json
  { message: "Article supprimé" }.to_json
end

Pour supprimer un article, on utilisera la méthode delete de Sinatra. On peut voir que le code est très similaire à la méthode get d’un article spécifique, sauf qu’ici on va ajouter la méthode delete de Ruby à notre tableau d’article pour le supprimer.

Une fois que vous avez fini de coder votre API, vous pouvez lancer votre application avec la commande ruby app.rb et vous rendre sur http://localhost:4567/ suivi de vos routes pour tester votre API.

Bonnes pratiques :

Dans une API en production, il est essentiel d’ajouter des validations pour vérifier les données reçues avant de les utiliser. Par exemple, vous pouvez utiliser une gem comme dry-validation ou écrire des méthodes de vérification simples dans Sinatra.

Conclusion

Voilà, vous avez vu comment créer un CRUD avec la gem Sinatra. Bluffant non ? Maintenant que je vous ai montré comment faire une API avec Sinatra, il faut quand même revenir sur quelques points importants. Malgré le fait que Sinatra ait de nombreuses qualités comme sa simplicité, sa rapidité, sa légèreté et sa flexibilité, il ne peut malheureusement pas convenir à tous les projets car il ne propose pas de structure particulière et ne propose pas de fonctionnalités avancées comme les migrations de base de données par exemple. Pour des projets plus complexes et de plus grande envergure, il sera beaucoup plus compliqué de configurer et de maintenir une application Sinatra par rapport à une application Rails, par exemple.

En résumé, Sinatra est un excellent choix si vous cherchez à développer une API RESTful rapidement, tout en gardant un maximum de contrôle sur votre code. Sa simplicité et sa légèreté le rende parfait pour des projets légers ou des microservices. Si ce framework vous intéresse, pourquoi ne pas tester cette approche sur votre prochain projet ? Vous pourriez être surpris par la puissance de Sinatra, même pour des tâches complexes.