Diferencias de servicios web entre REST y RPC

Tengo un servicio web que acepta parámetros JSON y tengo URL específicas para métodos, por ejemplo:

http://IP:PORT/API/getAllData?p={JSON}

Esto definitivamente no es REST ya que no es apátrida. Tiene en cuenta las cookies y tiene su propia sesión.

¿Es RPC? ¿Cuál es la diferencia entre RPC y REST?

No puede hacer una separación clara entre REST o RPC con solo mirar lo que publicó.

Una limitación de REST es que debe ser apátrida. Si tiene una sesión, entonces tiene un estado para que no pueda llamar a su servicio RESTful.

El hecho de que tenga una acción en su URL (es decir getAllData) es una indicación hacia RPC. En REST intercambias representaciones y la operación que realizas está dictada por los verbos HTTP. Además, en REST, la negociación de contenido no se realiza con un ?p={JSON}parámetro.

No sé si su servicio es RPC, pero no es RESTful. Puede aprender sobre la diferencia en línea, aquí hay un artículo para comenzar: Desmontando los mitos de RPC y REST . Usted sabe mejor lo que hay dentro de su servicio, así que compare sus funciones con lo que es RPC y saque sus propias conclusiones.

Considere el siguiente ejemplo de API HTTP que modelan los pedidos que se realizan en un restaurante.

• La API de RPC piensa en términos de "verbos", exponiendo la funcionalidad del restaurante como llamadas a funciones que aceptan parámetros e invoca estas funciones a través del verbo HTTP que parece más apropiado: un 'get' para una consulta, etc., pero el nombre del verbo es puramente incidental y no tiene ninguna relación con la funcionalidad real, ya que se llama a una URL diferente cada vez . Los códigos de devolución están codificados a mano y forman parte del contrato de servicio.
• La API REST , por el contrario, modela las diversas entidades dentro del dominio del problema como recursos y usa verbos HTTP para representar transacciones contra estos recursos: POST para crear, PUT para actualizar y GET para leer. Todos estos verbos, invocados en la misma URL , proporcionan una funcionalidad diferente. Los códigos de retorno HTTP comunes se utilizan para transmitir el estado de las solicitudes.

Ordenando:

• RPC: http: // MyRestaurant: 8080 / Orders / PlaceOrder (POST: {Tacos object})
• DESCANSO: http: // MyRestaurant: 8080 / Orders / Order? OrderNumber = asdf (POST: {Tacos object})

Recuperando un pedido:

• RPC: http: // MyRestaurant: 8080 / Orders / GetOrder? OrderNumber = asdf (GET)
• DESCANSO: http: // MyRestaurant: 8080 / Orders / Order? OrderNumber = asdf (GET)

Actualización de un pedido:

• RPC: http: // MyRestaurant: 8080 / Orders / UpdateOrder (PUT: {objeto Pineapple Tacos})
• DESCANSO: http: // MyRestaurant: 8080 / Orders / Order? OrderNumber = asdf (PUT: {Pineapple Tacos object})

Ejemplo tomado de sites.google.com/site/wagingguerillasoftware/rest-series/what-is-restful-rest-vs-rpc

Como han dicho otros, una diferencia clave es que REST se centra en el sustantivo y RPC se centra en el verbo. Solo quería incluir esta tabla clara de ejemplos que demuestran que:

--------------------------- + ---------------------- --------------- + --------------------------
  Operación                  | RPC (operación)                      | REST (recurso)
--------------------------- + ---------------------- --------------- + --------------------------
 Registrarse | POST / registro | CORREO / personas           
--------------------------- + ---------------------- --------------- + --------------------------
 Dimitir | POST / dimitir | BORRAR / personas / 1234    
--------------------------- + ---------------------- --------------- + --------------------------
 Leer persona | GET / readPerson? Personid = 1234 | GET / personas / 1234       
--------------------------- + ---------------------- --------------- + --------------------------
 Leer la lista de elementos de la persona | GET / readUsersItemsList? Userid = 1234 | GET / personas / 1234 / artículos
--------------------------- + ---------------------- --------------- + --------------------------
 Agregar artículo a la lista de personas | POST / addItemToUsersItemsList | CORREO / personas / 1234 / artículos
--------------------------- + ---------------------- --------------- + --------------------------
 Actualizar elemento | POST / modifiedItem | PUT / items / 456          
--------------------------- + ---------------------- --------------- + --------------------------
 Eliminar elemento | POST / removeItem? ItemId = 456 | BORRAR / items / 456       
--------------------------- + ---------------------- --------------- + --------------------------

Notas

• Como muestra la tabla, REST tiende a usar parámetros de ruta de URL para identificar recursos específicos
  (p GET /persons/1234. Ej. ), Mientras que RPC tiende a usar parámetros de consulta para entradas de funciones
  (p GET /readPerson?personid=1234. Ej .).
• No se muestra en la tabla cómo una API REST manejaría el filtrado, que normalmente implicaría parámetros de consulta (por ejemplo GET /persons?height=tall).
• Tampoco se muestra cómo con cualquiera de los sistemas, cuando crea / actualiza operaciones, es probable que se pasen datos adicionales a través del cuerpo del mensaje (por ejemplo, cuando lo hace POST /signupo POST /personsincluye datos que describen a la nueva persona).
• Por supuesto, nada de esto está escrito en piedra, pero le da una idea de lo que es probable que encuentre y cómo podría querer organizar su propia API para mantener la coherencia. Para obtener más información sobre el diseño de URL REST, consulte esta pregunta .

Es RPC usando http . Una implementación correcta de REST debería ser diferente de RPC. Tener una lógica para procesar datos, como un método / función, es RPC. getAllData () es un método inteligente. REST no puede tener inteligencia, debe ser un volcado de datos que pueda ser consultado por una inteligencia externa .

La mayoría de las implementaciones que he visto en estos días son RPC, pero muchos lo llaman erróneamente REST. REST con HTTP es el salvador y SOAP con XML el villano. Entonces tu confusión está justificada y tienes razón, no es DESCANSO.

El protocolo HTTP no realiza una implementación de REST. Tanto REST (GET, POST, PUT, PATCH, DELETE) como RPC (GET + POST) se pueden desarrollar a través de HTTP (por ejemplo: a través de un proyecto de API web en Visual Studio).

Bien, pero ¿qué es DESCANSO entonces? El modelo de madurez de Richardson se presenta a continuación (resumido). Solo el nivel 3 es DESCANSO.

• Nivel 0: Http POST
• Nivel 1: cada recurso / entidad tiene un URI (pero solo POST)
• Nivel 2: se pueden usar POST y GET
• Nivel 3 (RESTful): utiliza HATEOAS (hipervínculos de medios) o, en otras palabras, enlaces autoexploratorios

por ejemplo: nivel 3 (HATEOAS):

1. El enlace indica que este objeto se puede actualizar de esta manera y agregar de esta manera.

2. El enlace indica que este objeto solo se puede leer y así es como lo hacemos.

   Claramente, enviar datos no es suficiente para convertirse en REST, pero también debe mencionarse cómo consultar los datos. Pero, de nuevo, ¿por qué los 4 pasos? ¿Por qué no puede ser solo el Paso 4 y llamarlo DESCANSO? Richardson nos acaba de dar un enfoque paso a paso para llegar allí, eso es todo.

Ha creado sitios web que pueden ser utilizados por humanos. ¿Pero también puede crear sitios web que sean utilizables por máquinas? Ahí es donde está el futuro, y RESTful Web Services le muestra cómo hacerlo.

• Este libro RESTful Web Services ayuda
• Una lectura muy interesante RPC vs REST

PD: REST es muy popular, al igual que las pruebas automatizadas, pero cuando se trata de ejemplos del mundo real ... bueno ...

REST se describe mejor para trabajar con los recursos, mientras que RPC trata más sobre las acciones.

REST significa Transferencia de Estado Representacional. Es una forma sencilla de organizar interacciones entre sistemas independientes. Las aplicaciones RESTful comúnmente usan solicitudes HTTP para publicar datos (crear y / o actualizar), leer datos (por ejemplo, realizar consultas) y eliminar datos. Por lo tanto, REST puede usar HTTP para las cuatro operaciones CRUD (Crear / Leer / Actualizar / Eliminar).

RPC se utiliza básicamente para comunicarse a través de los diferentes módulos para atender las solicitudes de los usuarios. Por ejemplo, en opentack como cómo nova, look y neutron funcionan juntos al arrancar una máquina virtual.

Yo diría así:

¿Mi entidad tiene / es propietaria de los datos? Entonces RPC: aquí hay una copia de algunos de mis datos, manipule la copia de datos que le envío y devuélvame una copia de su resultado.

¿La entidad llamada posee / posee los datos? Luego REST: o (1) muéstrame una copia de algunos de tus datos o (2) manipula algunos de tus datos.

En última instancia, se trata de qué "lado" de la acción posee o mantiene los datos. Y sí, puede usar la verborrea de REST para hablar con un sistema basado en RPC, pero seguirá haciendo actividad RPC al hacerlo.

Ejemplo 1: Tengo un objeto que se está comunicando con un almacén de base de datos relacional (o cualquier otro tipo de almacén de datos) a través de un DAO. Tiene sentido usar el estilo REST para esa interacción entre mi objeto y el objeto de acceso a datos que puede existir como una API. Mi entidad no posee / contiene los datos, la base de datos relacional (o el almacén de datos no relacionales) sí.

Ejemplo 2: Necesito hacer muchas matemáticas complejas. No quiero cargar un montón de métodos matemáticos en mi objeto, solo quiero pasar algunos valores a otra cosa que pueda hacer todo tipo de matemáticas y obtener un resultado. Entonces el estilo RPC tiene sentido, porque el objeto / entidad matemática expondrá a mi objeto un montón de operaciones. Tenga en cuenta que todos estos métodos pueden estar expuestos como API individuales y podría llamar a cualquiera de ellos con GET. Incluso puedo afirmar que esto es RESTful porque estoy llamando a través de HTTP GET, pero en realidad es RPC. Mi entidad posee / mantiene los datos, la entidad remota solo está realizando manipulaciones en las copias de los datos que le envié.

A través de HTTP, ambos terminan siendo solo HttpRequestobjetos y ambos esperan un HttpResponseobjeto de regreso. Creo que uno puede seguir codificando con esa descripción y preocuparse por otra cosa.

Aquí hay un montón de buenas respuestas. Todavía te recomendaría esto blog de Google, ya que hace un buen trabajo al discutir las diferencias entre RPC y REST y captura algo que no leí en ninguna de las respuestas aquí.

Citaría un párrafo del mismo enlace que me llamó la atención:

REST en sí mismo es una descripción de los principios de diseño que sustentan HTTP y la World Wide Web. Pero debido a que HTTP es la única API REST comercialmente importante, en su mayoría podemos evitar hablar de REST y solo centrarnos en HTTP. Esta sustitución es útil porque hay mucha confusión y variabilidad en lo que la gente piensa que significa REST en el contexto de las API, pero hay mucha mayor claridad y acuerdo sobre qué es HTTP en sí. El modelo HTTP es el inverso perfecto del modelo RPC: en el modelo RPC, las unidades direccionables son procedimientos y las entidades del dominio del problema están ocultas detrás de los procedimientos. En el modelo HTTP, las unidades direccionables son las propias entidades y los comportamientos del sistema están ocultos detrás de las entidades como efectos secundarios de su creación, actualización o eliminación.

Así es como los entiendo y los uso en diferentes casos de uso:

Ejemplo: gestión de restaurantes

caso de uso de REST : gestión de pedidos

- create order (POST), update order (PATCH), cancel order (DELETE), retrieve order (GET)
- endpoint: /order?orderId=123

Para la gestión de recursos, REST es limpio. Un punto final con acciones predefinidas. Puede verse una forma de exponer una base de datos (Sql o NoSql) o instancias de clase al mundo.

Ejemplo de implementación:

class order:
    on_get(self, req, resp): doThis.
    on_patch(self, req, resp): doThat.

Ejemplo de marco: Falcon para python.

caso de uso para RPC : gestión de operaciones

- prepare ingredients: /operation/clean/kitchen
- cook the order: /operation/cook/123
- serve the order /operation/serve/123

Para trabajos analíticos, operativos, no receptivos, no representativos y basados ​​en acciones, RPC funciona mejor y es muy natural pensar en funcional.

Ejemplo de implementación:

@route('/operation/cook/<orderId>')
def cook(orderId): doThis.

@route('/operation/serve/<orderId>')
def serve(orderId): doThat.

Ejemplo de marco: matraz para python