{"id":37978,"date":"2024-07-11T05:22:36","date_gmt":"2024-07-11T05:22:36","guid":{"rendered":"https:\/\/www.railscarma.com\/?p=37978"},"modified":"2024-07-11T05:22:40","modified_gmt":"2024-07-11T05:22:40","slug":"building-a-restful-api-using-grape-in-ruby-on-rails","status":"publish","type":"post","link":"https:\/\/www.railscarma.com\/fr\/blog\/building-a-restful-api-using-grape-in-ruby-on-rails\/","title":{"rendered":"Construire une API RESTful en utilisant Grape dans Ruby on Rails"},"content":{"rendered":"
\n\t\t\t\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t\t
\n\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t

In the realm of web development, creating RESTful APIs is a common necessity. RESTful APIs allow different systems to communicate over HTTP in a standardized way, making them integral to modern web applications. Ruby on Rails (RoR) provides a robust framework for web development, and with the addition of Grape, a micro-framework for creating APIs, building a RESTful API becomes even more streamlined and efficient. This article will guide you through the process of building a RESTful API using Grape in a Ruby on Rails application, complete with an example.<\/span><\/p>\n

What is Grape?<\/b><\/h2>\n

Grape is a Ruby framework specifically designed for creating REST-like APIs. It is lightweight and complements Rails well, offering a simple DSL (Domain-Specific Language) to define RESTful APIs. Grape allows you to focus on the API logic while handling common tasks such as parameter validation, formatting, and versioning.<\/span><\/p>\n

Setting Up Grape in a Rails Application<\/b><\/h2>\n

To get started, you need a Rails application. If you don’t have one already, you can create a new Rails application with:<\/span><\/p>\n

rails new grape_api_example
<\/span>cd grape_api_example<\/span><\/pre>\n
Add the Grape gem to your <\/span>Fichier de gemmes<\/b><\/span>:<\/b>
<\/span><\/p>\n
<\/p>\n
gem 'grape'<\/span><\/pre>\n
<\/p>\n
Courir <\/span>installation group\u00e9e<\/b> to install the gem.<\/span><\/p>\n
Creating the API<\/b><\/h2>\n
Create a new directory for your API under <\/span>app<\/b>:<\/span><\/p>\n
mkdir app\/api<\/span><\/pre>\n
<\/p>\n
Next, create a base class for your API. This class will inherit from <\/span>Grape::API<\/b> and serve as the foundation for your endpoints. Create a file <\/span>app\/api\/base_api.rb<\/b> and add the following code:<\/span><\/p>\n
API des modules
<\/span>  class Base < Grape::API
<\/span>    format :json
<\/span>    rescue_from :all do |e|
<\/span>      error_response(message: e.message, status: 500)
<\/span>    fin
<\/span>    mount API::V1::Base
<\/span>  fin
<\/span>fin<\/span><\/pre>\n
<\/p>\n
Versioning Your API<\/b><\/h2>\n
Versioning is crucial for maintaining backward compatibility. In this example, we will create version 1 of our API. Create a directory <\/span>app\/api\/v1<\/b> and a base file <\/span>app\/api\/v1\/base.rb<\/b>:<\/span><\/p>\n
API des modules
<\/span>  module V1
<\/span>    class Base < Grape::API
<\/span>      version 'v1', using: :path
<\/span>      mount API::V1::Users
<\/span>    fin
<\/span>  fin
<\/span>fin<\/span><\/pre>\n
<\/p>\n
Defining Endpoints<\/b><\/h3>\n
Let\u2019s create a simple endpoint for managing users. Create a file <\/span>app\/api\/v1\/users.rb<\/b>:<\/span><\/p>\n
module API\n  module V1\n    class Users < Grape::API\n      resource :users do\n        desc 'Return a list of users'\n        get do\n          User.all\n        end\n\n        desc 'Return a specific user'\n        params do\n          requires :id, type: Integer, desc: 'User ID'\n        end\n        route_param :id do\n          get do\n            User.find(params[:id])\n          end\n        end\n\n        desc 'Create a user'\n        params do\n          requires :name, type: String, desc: 'User name'\n          requires :email, type: String, desc: 'User email'\n        end\n        post do\n          User.create!({\n            name: params[:name],\n            email: params[:email]\n          })\n        end\n\n        desc 'Update a user'\n        params do\n          requires :id, type: Integer, desc: 'User ID'\n          requires :name, type: String, desc: 'User name'\n          requires :email, type: String, desc: 'User email'\n        end\n        put ':id' do\n          user = User.find(params[:id])\n          user.update({\n            name: params[:name],\n            email: params[:email]\n          })\n        end\n\n        desc 'Delete a user'\n        params do\n          requires :id, type: Integer, desc: 'User ID'\n        end\n        delete ':id' do\n          User.find(params[:id]).destroy\n        end\n      end\n    end\n  end\nend\n<\/pre>\n
Mounting the API<\/b><\/p>\n
To mount the API, you need to update your <\/span>config\/routes.rb:<\/b><\/p>\n
Rails.application.routes.draw faire
<\/span>  mount API::Base => '\/'
<\/span>fin<\/span><\/pre>\n
<\/p>\n
Cr\u00e9ation du mod\u00e8le utilisateur<\/b><\/h3>\n
To support the user endpoints, generate a User model:<\/span><\/p>\n
rails generate model User name:string email:string
<\/span>base de donn\u00e9es rails: migrer<\/span><\/pre>\n
<\/p>\n
Testing the API<\/b><\/h3>\n
Start your Rails server:<\/span><\/p>\n
rails server<\/span><\/pre>\n
<\/p>\n
You can now test your API endpoints using a tool like <\/span>curl<\/span> or Postman. Here are some example requests:<\/span><\/p>\n
Get all users:<\/b>
<\/span><\/p>\n
curl http:\/\/localhost:3000\/v1\/users<\/span><\/pre>\n
<\/p>\n
Get a specific user:<\/b>
<\/span><\/p>\n
curl http:\/\/localhost:3000\/v1\/users\/1<\/span><\/pre>\n
<\/p>\n
Create a new user:<\/b>
<\/span><\/p>\n
curl -X POST http:\/\/localhost:3000\/v1\/users -d \"name=John Doe&email=johndoe@example.com\"<\/span><\/pre>\n
Update a user:<\/b>
<\/span><\/p>\n
curl -X PUT http:\/\/localhost:3000\/v1\/users\/1 -d \"name=Jane Doe&email=janedoe@example.com\"<\/span><\/pre>\n
<\/p>\n
Delete a user:<\/b>
<\/span><\/p>\n
curl -X DELETE http:\/\/localhost:3000\/v1\/users\/1<\/span><\/pre>\n
<\/p>\n
Conclusion<\/b><\/h2>\n
Using Grape with Ruby on Rails provides a powerful combination for building RESTful APIs. Grape’s lightweight and flexible nature makes it easy to define and manage API endpoints, while Rails handles the underlying infrastructure. This example demonstrated a basic CRUD API for user management, showcasing how to set up and use Grape within a Application Rails<\/a>. With this foundation, you can extend the API to include more complex functionality and integrate it with other services.<\/span><\/p>\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/section>\n\t\t\t\t<\/div>\n\t\t  
\r\n        
Articles Similaires<\/div>\r\n    
\r\n\r\n            
\r\n            
\r\n    \r\n\r\n      \"Offliberty\r\n\r\n    <\/a>\r\n  <\/div>\r\n\r\n  \r\n        Qu'est-ce que Offliberty Ruby Gem et comment fonctionne-t-il ?  <\/a>\r\n\r\n        <\/div>\r\n              
\r\n            
\r\n    \r\n\r\n      \"M\u00e9thode\r\n\r\n    <\/a>\r\n  <\/div>\r\n\r\n  \r\n        M\u00e9thode Rails link_to : Le guide complet avec des exemples  <\/a>\r\n\r\n        <\/div>\r\n              
\r\n            
\r\n    \r\n\r\n      \"Construire\r\n\r\n    <\/a>\r\n  <\/div>\r\n\r\n  \r\n        Comment construire une plateforme SaaS \u00e9volutive en utilisant Ruby on Rails  <\/a>\r\n\r\n        <\/div>\r\n              
\r\n            
\r\n    \r\n\r\n      \"Ruby\r\n\r\n    <\/a>\r\n  <\/div>\r\n\r\n  \r\n        Guide de correspondance des expressions rationnelles en Ruby (2026) avec exemples  <\/a>\r\n\r\n        <\/div>\r\n      \r\n  <\/div>\r\n\r\n