Bygga ett RESTful API med Grape i Ruby on Rails

När det gäller webbutveckling är det vanligt att skapa RESTful API:er. RESTful API:er gör det möjligt för olika system att kommunicera över HTTP på ett standardiserat sätt, vilket gör dem till en integrerad del av moderna webbapplikationer. Ruby on Rails (RoR) tillhandahåller ett robust ramverk för webbutveckling, och med tillägget av Grape, ett mikroramverk för att skapa API:er, blir det ännu mer strömlinjeformat och effektivt att bygga ett RESTful API. Den här artikeln guidar dig genom processen att bygga ett RESTful API med hjälp av Grape i en Ruby on Rails-applikation, komplett med ett exempel.

Vad är druva?

Grape är ett Ruby-ramverk som är särskilt utformat för att skapa REST-liknande API:er. Det är lättviktigt och kompletterar Rails väl och erbjuder en enkel DSL (Domain-Specific Language) för att definiera RESTful API:er. Grape gör att du kan fokusera på API-logiken samtidigt som du hanterar vanliga uppgifter som parametervalidering, formatering och versionshantering.

Konfigurera Grape i en Rails-applikation

För att komma igång behöver du en Rails-applikation. Om du inte redan har en kan du skapa en ny Rails-applikation med:

rails ny grape_api_example
cd grape_api_example

Lägg till pärlan Grape i din Gemfil:

pärla "druva

Springa paketinstallation för att installera gemen.

Skapa API:et

Skapa en ny katalog för ditt API under app:

mkdir app/api

Skapa sedan en basklass för ditt API. Denna klass kommer att ärva från Grape::API och fungerar som grunden för dina slutpunkter. Skapa en fil app/api/base_api.rb och lägg till följande kod:

modul API
  klass Bas < Grape::API
    format :json
    rescue_from :all do |e|
      error_response(meddelande: e.meddelande, status: 500)
    slutet
    montera API::V1::Base
  slutet
slutet

Versionering av ditt API

Versionering är avgörande för att upprätthålla bakåtkompatibilitet. I det här exemplet kommer vi att skapa version 1 av vårt API. Skapa en katalog app/api/v1 och en basfil app/api/v1/base.rb:

modul API
  modul V1
    klass Bas < Grape::API
      version 'v1', användning: :sökväg
      montera API::V1::Användare
    slutet
  slutet
slutet

Definiera slutpunkter

Låt oss skapa en enkel endpoint för att hantera användare. Skapa en fil app/api/v1/användare.rb:

modul API
  Modul V1
    klass Användare < Grape::API
      resurs :användare do
        desc 'Returnera en lista med användare'
        get do
          Användare.alla
        slut

        desc 'Returnera en specifik användare'
        params do
          kräver :id, typ: Integer, desc: "Användar-ID
        slut
        route_param :id do
          get do
            User.find(params[:id])
          end
        slut

        desc 'Skapa en användare'
        parametrar do
          kräver :namn, typ: String, desc: 'Användarnamn'
          kräver :email, typ: String, desc: 'Användarens e-postadress'
        slut
        post gör
          Användare.skapa!({
            namn: params[:namn],
            e-post: params[:e-post]
          })
        slut

        desc 'Uppdatera en användare'
        parametrar do
          kräver :id, typ: Integer, desc: "Användar-ID
          kräver :namn, typ: String, desc: "Användarens namn
          kräver :email, typ: String, desc: "Användarens e-post
        slut
        put ':id' do
          användare = Användare.find(params[:id])
          user.update({
            namn: params[:namn],
            e-post: params[:e-post]
          })
        slut

        desc 'Ta bort en användare'
        parametrar do
          kräver :id, typ: Integer, desc: "Användar-ID
        slut
        ta bort ':id' do
          User.find(params[:id]).destroy
        end
      slut
    slut
  slut
slut

Montering av API

För att ansluta till API:et måste du uppdatera din config/routes.rb:

Rails.application.routes.draw gör
  mount API::Base => '/'
slutet

Skapa användarmodellen

För att stödja användarens slutpunkter, skapa en User-modell:

rails generate model Användarnamn:sträng email:sträng
skenor db:migrera

Testning av API:et

Starta din Rails-server:

Räls server

Du kan nu testa dina API-slutpunkter med hjälp av ett verktyg som krulla eller Postman. Här är några exempel på förfrågningar:

Hämta alla användare:

curl http://localhost:3000/v1/users

Hämta en specifik användare:

curl http://localhost:3000/v1/users/1

Skapa en ny användare:

curl -X POST http://localhost:3000/v1/users -d "name=John Doe&[email protected]"

Uppdatera en användare:

curl -X PUT http://localhost:3000/v1/users/1 -d "name=Jane Doe&[email protected]"

Ta bort en användare:

curl -X DELETE http://localhost:3000/v1/users/1

Slutsats

Att använda Grape med Ruby on Rails ger en kraftfull kombination för att bygga RESTful API:er. Grapes lättviktiga och flexibla natur gör det enkelt att definiera och hantera API-slutpunkter, medan Rails hanterar den underliggande infrastrukturen. I det här exemplet demonstreras ett grundläggande CRUD-API för användarhantering, som visar hur man konfigurerar och använder Grape inom en Rails ansökan. Med denna grund kan du utöka API:et till att omfatta mer komplexa funktioner och integrera det med andra tjänster.