{"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":"erstellung-einer-restful-api-mit-grape-in-ruby-on-rails","status":"publish","type":"post","link":"https:\/\/www.railscarma.com\/de\/blog\/erstellung-einer-restful-api-mit-grape-in-ruby-on-rails\/","title":{"rendered":"Aufbau einer RESTful API mit Grape in 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

Im Bereich der Webentwicklung ist die Erstellung von RESTful APIs eine allgemeine Notwendigkeit. RESTful-APIs erm\u00f6glichen die standardisierte Kommunikation verschiedener Systeme \u00fcber HTTP und sind somit ein wesentlicher Bestandteil moderner Webanwendungen. Ruby on Rails (RoR) bietet ein robustes Framework f\u00fcr die Webentwicklung, und mit dem Zusatz von Grape, einem Mikro-Framework f\u00fcr die Erstellung von APIs, wird die Erstellung einer RESTful-API noch schlanker und effizienter. Dieser Artikel f\u00fchrt Sie durch den Prozess der Erstellung einer RESTful-API mit Grape in einer Ruby on Rails-Anwendung, komplett mit einem Beispiel.<\/span><\/p>\n

Was ist eine Weintraube?<\/b><\/h2>\n

Grape ist ein Ruby-Framework, das speziell f\u00fcr die Erstellung von REST-\u00e4hnlichen APIs entwickelt wurde. Es ist leichtgewichtig und erg\u00e4nzt Rails gut. Es bietet eine einfache DSL (Domain-Specific Language) zur Definition von RESTful APIs. Grape erm\u00f6glicht es Ihnen, sich auf die API-Logik zu konzentrieren und gleichzeitig allgemeine Aufgaben wie Parametervalidierung, Formatierung und Versionierung zu erledigen.<\/span><\/p>\n

Einrichten von Grape in einer Rails-Anwendung<\/b><\/h2>\n

Um loszulegen, ben\u00f6tigen Sie eine Rails-Anwendung. Wenn Sie noch keine haben, k\u00f6nnen Sie eine neue Rails-Anwendung mit erstellen:<\/span><\/p>\n

Schienen neu grape_api_example
<\/span>cd grape_api_example<\/span><\/pre>\n
F\u00fcgen Sie den Edelstein Grape zu Ihrem <\/span>Gemfile<\/b><\/span>:<\/b>
<\/span><\/p>\n
<\/p>\n
Edelstein 'Traube'<\/span><\/pre>\n
<\/p>\n
Laufen <\/span>Bundle-Installation<\/b> um den Edelstein zu installieren.<\/span><\/p>\n
Erstellen der API<\/b><\/h2>\n
Erstellen Sie ein neues Verzeichnis f\u00fcr Ihre API unter <\/span>app<\/b>:<\/span><\/p>\n
mkdir app\/api<\/span><\/pre>\n
<\/p>\n
Als n\u00e4chstes erstellen Sie eine Basisklasse f\u00fcr Ihre API. Diese Klasse wird erben von <\/span>Weintraube::API<\/b> und dienen als Grundlage f\u00fcr Ihre Endpunkte. Eine Datei erstellen <\/span>app\/api\/base_api.rb<\/b> und f\u00fcgen Sie den folgenden Code hinzu:<\/span><\/p>\n
Modul-API
<\/span>  Klasse Base < Grape::API
<\/span>    format :json
<\/span>    rescue_from :all do |e|
<\/span>      error_response(message: e.message, status: 500)
<\/span>    Ende
<\/span>    einh\u00e4ngen API::V1::Base
<\/span>  Ende
<\/span>Ende<\/span><\/pre>\n
<\/p>\n
Versionierung Ihrer API<\/b><\/h2>\n
Die Versionskontrolle ist entscheidend f\u00fcr die Aufrechterhaltung der Abw\u00e4rtskompatibilit\u00e4t. In diesem Beispiel werden wir Version 1 unserer API erstellen. Erstellen Sie ein Verzeichnis <\/span>app\/api\/v1<\/b> und eine Basisdatei <\/span>app\/api\/v1\/base.rb<\/b>:<\/span><\/p>\n
Modul-API
<\/span>  Modul V1
<\/span>    Klasse Base < Grape::API
<\/span>      Version 'v1', mit: :Pfad
<\/span>      API::V1::Benutzer einh\u00e4ngen
<\/span>    Ende
<\/span>  Ende
<\/span>Ende<\/span><\/pre>\n
<\/p>\n
Definieren von Endpunkten<\/b><\/h3>\n
Lassen Sie uns einen einfachen Endpunkt f\u00fcr die Benutzerverwaltung erstellen. Eine Datei erstellen <\/span>app\/api\/v1\/users.rb<\/b>:<\/span><\/p>\n
Modul API\n  Baustein V1\n    Klasse Benutzer < Grape::API\n      resource :users do\n        desc 'R\u00fcckgabe einer Liste von Benutzern'\n        get do\n          Benutzer.alle\n        end\n\n        desc 'Einen bestimmten Benutzer zur\u00fcckgeben'\n        params do\n          requires :id, type: Integer, desc: 'Benutzer-ID'\n        end\n        route_param :id do\n          get do\n            User.find(params[:id])\n          end\n        end\n\n        desc 'Einen Benutzer erstellen'\n        params tun\n          requires :name, type: String, desc: 'Nutzername'\n          requires :email, type: String, desc: 'Benutzer-E-Mail'\n        end\n        post do\n          User.create!({\n            name: params[:name],\n            email: params[:email]\n          })\n        end\n\n        desc 'Einen Benutzer aktualisieren'\n        params tun\n          requires :id, type: Integer, desc: 'Benutzer-ID'\n          requires :name, type: String, desc: 'Nutzername'\n          requires :email, type: String, desc: 'Benutzer-E-Mail'\n        end\n        put ':id' do\n          Benutzer = Benutzer.find(params[:id])\n          user.update({\n            name: params[:name],\n            email: params[:email]\n          })\n        Ende\n\n        desc 'Einen Benutzer l\u00f6schen'\n        params tun\n          requires :id, type: Integer, desc: 'Benutzer-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
Montage der API<\/b><\/p>\n
Um die API einzubinden, m\u00fcssen Sie Ihre <\/span>config\/routes.rb:<\/b><\/p>\n
Rails.application.routes.draw tun
<\/span>  mount API::Base => '\/'
<\/span>Ende<\/span><\/pre>\n
<\/p>\n
Erstellen des Benutzermodells<\/b><\/h3>\n
Um die Benutzerendpunkte zu unterst\u00fctzen, erstellen Sie ein Benutzermodell:<\/span><\/p>\n
rails generate model Benutzername:string email:string
<\/span>Schienen db: migrieren<\/span><\/pre>\n
<\/p>\n
Testen der API<\/b><\/h3>\n
Starten Sie Ihren Rails-Server:<\/span><\/p>\n
Schienen-Server<\/span><\/pre>\n
<\/p>\n
Sie k\u00f6nnen nun Ihre API-Endpunkte mit einem Tool wie <\/span>locken.<\/span> oder Postman. Hier sind einige Beispielanfragen:<\/span><\/p>\n
Erhalten Sie alle Benutzer:<\/b>
<\/span><\/p>\n
http:\/\/localhost:3000\/v1\/users locken.<\/span><\/pre>\n
<\/p>\n
Einen bestimmten Benutzer abrufen:<\/b>
<\/span><\/p>\n
http:\/\/localhost:3000\/v1\/users\/1 locken.<\/span><\/pre>\n
<\/p>\n
Erstellen Sie einen neuen Benutzer:<\/b>
<\/span><\/p>\n
curl -X POST http:\/\/localhost:3000\/v1\/users -d \"name=John Doe&email=johndoe@example.com\"<\/span><\/pre>\n
Aktualisieren Sie einen Benutzer:<\/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
L\u00f6schen Sie einen Benutzer:<\/b>
<\/span><\/p>\n
curl -X DELETE http:\/\/localhost:3000\/v1\/users\/1<\/span><\/pre>\n
<\/p>\n
Abschluss<\/b><\/h2>\n
Die Verwendung von Grape mit Ruby on Rails bietet eine leistungsstarke Kombination f\u00fcr die Erstellung von RESTful APIs. Die leichtgewichtige und flexible Natur von Grape macht es einfach, API-Endpunkte zu definieren und zu verwalten, w\u00e4hrend Rails die zugrunde liegende Infrastruktur verwaltet. Dieses Beispiel demonstriert eine grundlegende CRUD-API f\u00fcr die Benutzerverwaltung und zeigt, wie man Grape innerhalb einer Website einrichtet und verwendet. Rails-Anwendung<\/a>. Auf dieser Grundlage k\u00f6nnen Sie die API um komplexere Funktionen erweitern und sie in andere Dienste integrieren.<\/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        
zusammenh\u00e4ngende Posts<\/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        Was ist Offliberty Ruby Gem und wie funktioniert es?  <\/a>\r\n\r\n        <\/div>\r\n              
\r\n            
\r\n    \r\n\r\n      \"Rails\r\n\r\n    <\/a>\r\n  <\/div>\r\n\r\n  \r\n        Rails link_to Methode: Die vollst\u00e4ndige Anleitung mit Beispielen  <\/a>\r\n\r\n        <\/div>\r\n              
\r\n            
\r\n    \r\n\r\n      \"Aufbau\r\n\r\n    <\/a>\r\n  <\/div>\r\n\r\n  \r\n        Wie man eine skalierbare SaaS-Plattform mit Ruby on Rails aufbaut  <\/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        Ruby Regex Match Guide (2026) mit Beispielen  <\/a>\r\n\r\n        <\/div>\r\n      \r\n  <\/div>\r\n\r\n