No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Estructura REST API

7/19
Recursos

Aportes 58

Preguntas 6

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

👨‍💻 Reto sobre gestionar productos.

EndPoint Method Body Response status
------------ ---------- ------- -------------- ----------
/products GET N/A [{}, {}, …] 200
------------ ---------- ------- -------------- ----------
/products/:id GET N/A {} 200
------------ ---------- ------- -------------- ----------
/products/categories GET N/A [{}, {}, …] 200
------------ ---------- ------- -------------- ----------
/products POST {…} {…} 201
------------ ---------- ------- -------------- ----------
/products/:id PUT { } { } 201
------------ ---------- ------- -------------- ----------
/products/:id PATCH { } { } 201
------------ ---------- ------- -------------- ----------
/products/:id DELETE N/A true / false 201
------------ ---------- ------- -------------- ----------

Espero sirva de reto.

Saludos

REST (Representational State Transfer) API es un estilo de arquitectura de software que se utiliza para construir servicios web. Una API REST es una interface que se utiliza para interconectar sistemas o aplicaciones, y permite que estos sistemas o aplicaciones envíen y reciban datos entre sí a través de la red.

Una API REST se basa en el protocolo HTTP, y utiliza operaciones HTTP como GET, POST, PUT y DELETE para realizar diversas acciones sobre los datos almacenados en un servidor. Estas operaciones son conocidas como métodos HTTP, y corresponden a las acciones CRUD (Create, Read, Update, Delete) que se pueden realizar sobre los datos.

Por ejemplo, si tienes una aplicación web que almacena información de contactos, podrías utilizar una API REST para permitir que otras aplicaciones accedan y utilicen los datos de tus contactos. La aplicación podría exponer una API REST que permita a otras aplicaciones realizar operaciones como crear un nuevo contacto, obtener la lista de todos los contactos, modificar la información de un contacto existente o eliminar un contacto.

Una API REST se utiliza a menudo para construir servicios web que pueden ser utilizados por diversas aplicaciones o sistemas, y es una forma común de permitir la integración entre diferentes sistemas y plataformas.

La diferencia entre PUT y PATCH es:

  • PUT == enviará todos los datos
  • PATCH == enviará los datos que se están actualizando

Reto de endpoint CRUD de unos productos
Create:

/product #POST

Read:

/product #GET
/product/:id #GET

Update

/product/:id  #PUT/PATCH

Delete

/product/:id #DELETE

El status code para DELETE con éxito es 200, no 201.
Incluso lo marcan así en la documentación de Mozilla

APIs en mundo real

Las APIs se aplican en una amplia variedad de aplicaciones y servicios en el mundo real. Algunos ejemplos de cómo se utilizan las APIs en diferentes industrias y aplicaciones incluyen:

  1. Comercio electrónico: Las APIs se utilizan para permitir a las tiendas en línea acceder a los servicios de pago, como PayPal o Stripe, para procesar pagos de los clientes.
  2. Redes sociales: Las APIs de redes sociales, como Facebook, Twitter e Instagram, permiten a los desarrolladores crear aplicaciones que se integran con estas plataformas y acceden a los datos de los usuarios.
  3. Transporte: Las APIs se utilizan en aplicaciones de transporte para mostrar información sobre las rutas, horarios, tarifas y disponibilidad de transporte público, así como para permitir a los usuarios reservar y pagar por viajes.
  4. Finanzas: Las APIs se utilizan en aplicaciones financieras para acceder a los datos de la bolsa, las tasas de cambio de divisas, los informes de crédito y otras fuentes de información financiera.
  5. Salud: Las APIs se utilizan en aplicaciones de salud para acceder a datos de pacientes, información de seguros, registros médicos y otros datos de salud importantes.
  6. Servicios gubernamentales: Las APIs se utilizan en aplicaciones gubernamentales para proporcionar información sobre los servicios, procesos y leyes gubernamentales, y permitir a los ciudadanos realizar trámites y solicitudes en línea.

7 - Estructura REST API

API REST es un estandar para desarrollar APIs que funcionan en el protocolo HTTP, cualquier framework que elijas tiene esta implementacion

  • A través de los endpoints se le pide información al dominio, por lo general se nos devuelve la información empaquetada en un JSON.

Como funciona?

  • CRUD es el índice de unas palabras clave, y en el protocolo HTTP tenemos métodos para llevarlas a cabo:
    • Create (crear) → POST
    • Read (leer) → GET
    • Delete (eliminar) → DELETE
    • Update (actualizar) → PUT / PATCH
      • PUT envía la totalidad de los datos, mientras que patch envía solo los datos destinados a actualizarse

Ejemplo de métodos a un endpoint:

Endpoint method body response status
/users GET N/A [ { }, { }…] 200
/users/:id GET N/A { } 200
/users POST {…} {…} 201
/users/:id PUT / PATCH {…} {…} 201
/users/:id DELETE N/A ✅ (true o false) 201
endpoint method body response status
/products get N/A [{},{},…] 200
/products/:id get N/A {} 200
/products post {…} {…} 201
/products/:id put/patch {…} {…} 201
/products/:id delete N/A check 201

axios es un cliente HTTP muy utilizado para hacer peticiones al back-end.

https://axios-http.com/

PUT y PATCH es:
PUT => enviará todos los datos
PATCH => enviará los datos que se están actualizando

Comparto mi solución al reto:

endpoint method body response status
/products GET N/A [ {}, {} ... ] 200
/products/:id GET N/A {} 200
/products POST { ... } { ... } 201
/products/:id PUT/PATCH { ... } { ... } 200
/products/:id DELETE N/A - 200

el CRUD en Base de Datos
Create = CREATE /INSERT ejemplo CREATE SCHEMA/INSERT INTO table_name
Read = SELECT
Update = UPDATE
Delete = DELETE

Hola... Comparto mi solución al reto. ![](https://static.platzi.com/media/user_upload/image-ea0b6cee-f838-4f6c-b650-bc25866c1b40.jpg) Si hay algún error o alguna inquietud, hazmela saber 👌😉
![](https://static.platzi.com/media/user_upload/image-9af656b4-8a4c-4447-bf74-cbee2a00b743.jpg)
Mi solución al reto ![](https://static.platzi.com/media/user_upload/image-bcab9ee3-d553-4d2d-8a52-413b18302cc6.jpg)
Excelente explicación del estándar y el uso de los diferentes métodos HTTP
**Proceso** | **Endpoint | Method | Body | Response | Status |** **Consultar todos los productos |** /products **|** GET **|** N/A **|** \[{1, pera}, {2, mango}] | 200 | **Consultar un producto |** /products/:id1 **|** GET **|** N/A **|** \[{1, pera}] | 200 | **Crear un producto |** /products **|** POST **|**{3, mora }]**|** {3, mora }] | 201 | **Actualizar un producto |** /products/:id1 **|** PATCH **|**\[{1, papaya}]**|** \[{1, papaya}] | 201 | **Borrar un producto |** /products/:id1 **|** DELETE **|**\[{1, papaya}]**|** TRUE | 201 |
EndPoint Method Body Response Status /Products GET N/A \[{}, {}, ...] 200 /Products/:id GET N/A {} 200 /Products POST { ... } { ... } 201 /Products/:id PUT/PATCH { ... } { ... } 201 /Products/:id DELETE N/A ok 201
* **CRUD** (Create, Read, Update, Delete) *es un **acrónimo** que **describe** las **cuatro** **operaciones** **básicas** **necesarias** para **interactuar** con una **base** de **datos** o **sistema** de **almacenamiento** de **datos**. Estas **operaciones** son **fundamentales** para el **manejo** y **gestión** de la **información** en **aplicaciones** de **software**.* **CRUD** *es una **metodología** **esencial** en el **desarrollo** de **aplicaciones** **web** y **sistemas** de **gestión** de **bases** de **datos**, **proporcionando** una **estructura** **clara** y **consistente** para el **desarrollo** de **funcionalidades** **relacionadas** con el **manejo** de **datos**. **Implementar** estas **operaciones** de manera **eficiente** y **segura** es **crucial** para **garantizar** la **integridad** y **accesibilidad** de la **información**.*
* **CRUD** **CRUD**** (Create, Read, Update, Delete) *es un **acrónimo** que **describe** las **cuatro** **operaciones** **básicas** **necesarias** para **interactuar** con una **base** de **datos** o **sistema** de **almacenamiento** de **datos**. Estas **operaciones** son **fundamentales** para el **manejo** y **gestión** de la **información** en **aplicaciones** de **software**.* **CRUD** *es una **metodología** **esencial** en el **desarrollo** de **aplicaciones** **web** y **sistemas** de **gestión** de **bases** de **datos**, **proporcionando** una **estructura** **clara** y **consistente** para el **desarrollo** de **funcionalidades** **relacionadas** con el **manejo** de **datos**. **Implementar** estas **operaciones** de manera **eficiente** y **segura** es **crucial** para **garantizar** la **integridad** y **accesibilidad** de la **información**.*
* **CRUD** **CRUD**** (Create, Read, Update, Delete) *es un **acrónimo** que **describe** las **cuatro** **operaciones** **básicas** **necesarias** para **interactuar** con una **base** de **datos** o **sistema** de **almacenamiento** de **datos**. Estas **operaciones** son **fundamentales** para el **manejo** y **gestión** de la **información** en **aplicaciones** de **software**.* **CRUD** *es una **metodología** **esencial** en el **desarrollo** de **aplicaciones** **web** y **sistemas** de **gestión** de **bases** de **datos**, **proporcionando** una **estructura** **clara** y **consistente** para el **desarrollo** de **funcionalidades** **relacionadas** con el **manejo** de **datos**. **Implementar** estas **operaciones** de manera **eficiente** y **segura** es **crucial** para **garantizar** la **integridad** y **accesibilidad** de la **información**.*
**REST API** *Las* **REST API**** (Representational State Transfer Application Programming Interfaces) *son un tipo de* **API** *que **sigue** los **principios** de la **arquitectura*** **REST***, una **norma** para **diseñar** **servicios** **web** **escalables** y **eficientes**.* **REST** ***utiliza** las **operaciones** **básicas** de* **HTTP***, como* **GET***,* **POST***,* **PUT** *y* **DELETE***, para **interactuar** con **recursos** **representados** en **formato*** **JSON** *o* **XML***. **Cada** **recurso** se **identifica** mediante una* **URI**** (Uniform Resource Identifier) ***única**. Las* **REST API** *son **conocidas** por su **simplicidad** y **flexibilidad**, permitiendo a los **desarrolladores** **construir** **aplicaciones** que pueden **comunicarse** **fácilmente** con **diversos** **servicios** y **plataformas**. Gracias a su **diseño** **basado** en **estándares** **abiertos**, las* **REST API *facilitan*** *la **interoperabilidad entre sistemas** y son **ampliamente** **adoptadas** en el **desarrollo** de **aplicaciones web modernas**.*
![](https://static.platzi.com/media/user_upload/image-e99347e5-472c-47e6-85fc-64c533a56cfe.jpg)
por temas de seguridad, que tan recomendado es usar parámetros en la URL?
EndePoint Method Body Reponse Status \----------- ---------------------------------------- /producto GET N/A \[{},{},...] 200 /producto/:id GET N/A {} 200 /producto GET N/A {} 200 products/categories GET N/A \[{},{}, ...] 200 /products POST {...} {...} 201 /products/:id PUT { } { } 201 /products/:id PATCH { } { } 201 /products/:id DELETE N/A true / false 201
Mi respuesta al trabajo, solo tuve 10 min. ![](https://static.platzi.com/media/user_upload/image-3a8d33f9-8a97-456f-b98b-4210e795496e.jpg)
Considero que en este curso debió darse una explicación previa sobre JSON, para poder interiorizar mejor los conceptos de la respuesta por parte del servidor y de renderizado por parte del cliente.
Creo yo. Lista de productos /productos Method: GET Body (N/A) Responde {} 200 /productos/:id Method: Get Body (N/A) Responde {} 200 /productos Method : POST Body (Escoba) Responde {Escoba} 201 /productos/:id Method: Delete Body (N/A) 201

Endpoint Method Body Response Status
/products Get N/A [ {}, {}…] 200
/products/:id Get N/A {} 200
/products POST {……} {……} 201
/products/:id PUT / PATCH {……} {……} 201
/products/:id DELETE N/A Ok 201

Me gusto la estructura de un link API Rest. Lo que me gustaria aprender es como se junta la estructura del codigo de su funcionalidad antes de agregarlo al link de las APIs.
![](

Intentando resolver lo que pidió el profe! espero sirva

PONGAN subtitulos como en youtube a los videos porque no se le entiende al profe a veces con la diccion y con el audio…ademas de transgenero yo tengo problemas auditivos…discapacidad auditiva.

endpoint method body response status
/products GET N/A [ {}, {}, {}] 200
/products/:id GET N/A {} 200
/products POST { … } { … } 201
/products/:id PUT { … } { … } 200
/products/:id DELETE N/A true or false 204
Endpoint Method Body Response Status
/products GET N/A [{},{},{}…] 200
/products/:id GET N/A {} 200
/products POST {…} {…} 201
/products/:id PUT/PATCH {…} {…} 201
/products/:id DELETE N/A check 201

muy buen clase

me re encanta este profe, y ya enteindo muchas cosas que haciamos con el profe gordito y el loco de pelo rizado ^ ^

Una API (Interfaz de Programación de Aplicaciones) es una herramienta que permite la comunicación entre sistemas o aplicaciones, permitiendo el intercambio de datos a través de la red. Un tipo de API es la API REST (Transferencia de Estado Representacional), que es un estilo arquitectónico utilizado para construir servicios web. Las API REST se basan en el protocolo HTTP y emplean operaciones HTTP como GET, POST, PUT y DELETE para manipular datos almacenados en un servidor. Estas operaciones son conocidas como métodos HTTP y se relacionan con las acciones CRUD (Crear, Leer, Actualizar, Eliminar) que pueden realizarse sobre los datos.

endpoint : /admin
method : get
body : N/A
response : [ {},{}…]
status : 200

endpoint : /admin
method : post
body : {…}
response : {…}
status : 201

endpoint : /admin/21
method : put
body : {[Solo la información que se actualizara]}
response : {[Devuelve en formato JSON el usuario con la actualización]}
status : 200

endpoint : /admin/21
method : delete
body : N/A
response : True
status : 200

(En los formatos que han sido creados en las pruebas me dió el status code de 200, no sé porqué el profesor coloco que 201, para mí tiene logica que de 200 ya que te da a entender que el proceso fue exitoso, el 201 es de creado y si al eliminar un usuario te lanza un status de creado entonces no me parece)

Mi respuesta hacia el reto:

Create
Endpoint: /products
Method: /POST
Body: [ {name^}{price}…]
Response: {product created}
Status: 201

Read
Endpoint: /products:id
Method: /GET
Body: [ {}]
Response: [ {name^}{price}…]
Status: 200

Update
Endpoint: /products:id#patch
Method: /PATCH
Body: [ {name: Arroz}]
Response: [ {name: Arroz}{price…}…]
Status: 200

Delete
Endpoint: /products:id
Method: /DELETE
Body: [ {}]
Response: [{Delete product}]
Status: 202

Otra arquitectura común hoy en día para las aplicaciones en tiempo real son los websockets. Si usaramos REST API habría que consultar al back infinitas veces y podríamos bloquear el server. Los websockets solucionan eso =D

Endpoint method body response status
/products POST {…} {…} 201
/products/:id GET N.A {} 200
/products/:id PUT/PATCH {…} {…} 201
/products/:id DELETE N.A true 201

| /product | GET | N/A | [{}…{}] | 200 |
| /product/:id | GET | N/A | {…} | 200 |
| /product | POST | {…} | {…} | 201 |
| /product/:id | PUT/PATCH | {…} | {…} | 200 |
| /product/:id | DELETE | N/A | true or false | 201 |

Ejemplo
La url de acceso https://lalechoneria.com/

-Endpoint para crear un producto
https://lalechoneria.com/productos/ #Método POST

-Endpoint para editar un producto
https://lalechoneria.com/productos/:id #Método PUT

-Endpoint para eliminar un producto
https://lalechoneria.com/productos/:id #Método DELETE

  • REST API es un estandar para crear APIs que cumplen con el protocolo HTTP

  • CRUD son las acciones que podemos hacer (Create (crear), Read (revisar), Update (actualizar), Delete (eliminar))

  1. Primero debemos solicitar el endpoint (ruta) para saber qué es lo que estamos buscando. En el ejemplo de los productos sería algo así como: productos/:id

  2. Después verificar que acción vamos a realizar. POST -> para agregar
    GET -> para revisar
    PUT/PATCH -> para actualizar y
    DELETE -> para eliminar

  3. Dependiendo el tipo de solicitud podemos enviar o no información. En el caso de agregar un nuevo producto enviariamos algo como:
    {
    name: sucaritas
    type: cereal
    price: $
    etc
    }

  4. Respondemos con la información que se está solicitando después. En el ejemplo de crear, podriamos regresar el mismo objeto que enviamos.

  5. Por último debemos enviar el status de la petición. En este caso, el 201 para informar que el producto se agregó con exito.

Crear

/producto #POST

leer

/producto
/producto/:id #GET

Actualizar

/producto/:id #PUT/PATCH

Eliminar

/producto/:id #DELETE

/Produs GET N/A [{},{}…] 200
/Produs/:IdPro GET N/A {} 200
/Produs POST {…} {…} 2001
/Produs/:IdPro PUT/PATCH {…} {…} 2001
/Produs/:IdPro DELETE N/A TRUE/FALSE 2001

La responsabilidad del método PATCH en una arquitectura REST API es permitir a los clientes actualizar un recurso existente mediante el envío de una solicitud que contenga solo los cambios que desean realizar. Esto significa que los clientes pueden actualizar solo los campos que necesitan sin tener que enviar toda la información del recurso, lo que puede ser beneficioso en términos de ancho de banda y rendimiento. Tambien el método PATCH permite a los clientes realizar actualizaciones parciales de un recurso, lo que puede ser útil cuando solo se necesita actualizar una pequeña parte del recurso en lugar de reemplazar todo el recurso.

endpoint method body response status
/Produs GET N/A [{},{}…] 200
/Produs/:IdPro GET N/A {} 200
/Produs POST {…} {…} 2001
/Produs/:IdPro PUT/PATCH {…} {…} 2001
/Produs/:IdPro DELETE N/A TRUE/FALSE 2001

anteriormente había otro curso de introducción al desarrollo backend que la verada lo hacia mal fácil y entendible

create(crear)— post
read (leer)— get
update(actualizar) – put ( actualizar cambios una lista de un usuario) patch ( actualizar el cambio en una lista del usuario
detelte ( eliminar) – delete

repetir la clase 3 veces ne ayudo

PUT y PATCH es:

PUT => enviará todos los datos
PATCH => enviará los datos que se están actualizando

Enpoints de productos Crud

Consultar todos los productos

/product #GET

Consultar un producto en específico

/product/:id #GET

Crear un producto

/product #POST

Actualizar un producto

/product/:id #PUT

Actualizar solo lo modificado en el producto

/product/:id #PATCH

Eliminar un producto

/product/:id #DELETE
Hola! Yo hice los endpoints y las respuestas de una manera muy sencilla. \-------------------------------- Crear PUT/products { names = jugos x quantity = 100 } 200 Created { names = jugos x quantity = 100 } \---------------------------------------- Eliminar DETELE/products/jugosx 400 { You are not authorized to delete the product. } \------------------------------------ Actualizar PUT/products/jugosx } quantity = 500 } 200 OK { names = jugos x quantity = 500 } \------------------------------------- Consultar GET/products/fresas 200 OK { names = jugos x quantity = 500 } \-------------------------------------