Modelo de Informe Practica #12 - 2022

UCSM Esc. Prof.
de Ingeniería de Sistemas INFORME DE PRÁCTICAS

Noviembre - 2022 DESARROLLO DE
APLICACIONES
Práctica N° 12: Servicios Rest Node JS

Elaborado por:
N° APELLIDOS Y NOMBRES DNI %PARTICIPACIÓN
1 Fernandez Lopez Luciana Alexandra 60482787 100%
2 Ordoñez Arratia Joseph Fernando 72085121 100%
3 Yanarico Suyo Cinthya Daniela 72937262 100%
© IEEE 2013 The Institute of Electrical and Electronics Engineers, Inc.

Práctica N° 12: Servicios REST Node.js
GRUPO N° 3
PRÁCTICAS DE DESARROLLO DE APLICACIONES
Presentado por:
2020700992 FERNANDEZ LOPEZ, LUCIANA ALEXANDRA
2020245441 ORDOÑEZ ARRATIA, JOSEPH FERNANDO
2020231692 YANARICO SUYO, CINTHYA DANIELA
ii
RECONOCIMIENTOS
Los autores de este trabajo reconocen con gratitud a los creadores de Node JS y Express
PALABRAS CLAVES
Node JS y Express, REST, API, Postman, Json, Token.
iii
ÍNDICE
1. RESÚMEN 1
2. INTRODUCCIÓN ...........................................................................................................1
3. MARCO TEÓRICO ........................................................................................................1
3.1 REST .....................................................................................................................1
3.2 API .........................................................................................................................2
4. EXPERIENCIAS DE PRÁCTICA ...................................................................................3
4.1 Crear el entorno del proyecto ...............................................................................3
4.2 Verificando los registros extraídos .......................................................................6
4.3 USAR JWT ......................................................................................................... 15
5. EJERCICIOS............................................................................................................... 17
5.1 Ejercicio 1........................................................................................................... 17
5.2 Ejercicio 2........................................................................................................... 22
6. CONCLUSIONES DE LA PRÁCTICA: ....................................................................... 25
7. CUESTIONARIO ......................................................................................................... 25
8. BIBLIOGRAFÍA ........................................................................................................... 28
iv
ÍNDICE DE TABLAS Y FIGURAS

Ilustracción 1: Arquitectura REST.......................................................................................2
Ilustración 2: Código de endpoint de POST ........................................................................3
v
1. RESÚMEN
En el presente informe se desarrolla el uso de REST y API, sabiendo que la Transferencia de Estado
Representacional (REST) es un estilo arquitectónico que define un conjunto de restricciones que se
utilizan para crear servicios web. La API REST es una forma de acceder a los servicios web de
forma sencilla y flexible, sin necesidad de procesarlos.
Igual que una interfaz de usuario permite la interacción y comunicación entre un software y una
persona, una API (acrónimo de Application Programming Interface) facilita la relación entre dos
aplicaciones para el intercambio de mensajes o datos. Los extremos de la API de Postman le
permiten integrar Postman dentro de su cadena de herramientas de desarrollo. Puede agregar nuevas
colecciones, actualizar colecciones existentes, actualizar entornos y agregar y ejecutar monitores
directamente a través de la API. Esto le permite acceder mediante programación a los datos
almacenados en su cuenta de Postman. Un procedimiento almacenado (stored procedure en inglés)
es un programa almacenado físicamente en una base de datos. Su implementación varía de un gestor
de bases de datos a otro. La ventaja de un procedimiento almacenado es que, al ser ejecutado, en
respuesta a una petición de usuario, es ejecutado directamente en el motor de bases de datos, el cual
usualmente corre en un servidor separado.
2. INTRODUCCIÓN
Una API REST es una interfaz de comunicación entre sistemas de información que usa el protocolo
de transferencia de hipertexto (hypertext transfer protocol o HTTP, por sus siglas en inglés) para
obtener datos o ejecutar operaciones sobre dichos datos en diversos formatos, como pueden ser
XML o JSON. Hay cuatro tipos de API de servicios web habituales entre los desarrolladores: SOAP
(Simple Object Access Protocol), un protocolo estándar de intercambio de información y datos en
XML entre dos objetos; XML-RPC, un protocolo de llamada a procedimiento remoto que usa XML
como formato de datos y llamadas HTTP como sistema de comunicación; JSON-RPC, mismo
protocolo pero en formato JSON; y REST (Representational State Transfer), arquitectura de
software para sistemas hipermedia en la World Wide Web; una API REST usa el protocolo HTTP.
REST es cualquier interfaz entre sistemas que use HTTP para obtener datos o generar operaciones
sobre esos datos en todos los formatos posibles, como XML y JSON. Se apoya en HTTP, los verbos
que utiliza son exactamente los mismos, con ellos se puede hacer GET, POST, PUT y DELETE. De
aquí surge una alternativa a SOAP.Cuando hablamos de SOAP hablamos de una arquitectura
divididas por niveles que se utilizaba para hacer un servicio, es más complejo de montar como de
gestionar y solo trabajaba con XML.
JSON Web Token (abreviado JWT) es un estándar abierto basado en JSON para la creación de
tokens de acceso que permiten la propagación de identidad y privilegios, Etán diseñados para ser
compactos, poder ser enviados en las URLs -URL-safe- y ser utilizados en escenarios de Single
Sign-On (SSO). Los privilegios de los JSON Web Tokens pueden ser utilizados para propagar la
identidad de usuarios como parte del proceso de autenticación entre un proveedor de identidad y un
proveedor de servicio, o cualquiera otro tipo de privilegios requeridos por procesos empresariales.
1
3. MARCO TEÓRICO
3.1 REST
¿Qué es?
Conocida como Transferencia de Estado Representacional, una arquitectura aplicada en las
aplicaciones Web y usa el protocolo HTTP ya sea para obtener o generar operaciones sobre los
datos, devolviéndolos en formatos como XML y JSON, entre las operaciones encontramos POST,
GET, PUT Y DELETE.
Existen 6 limitantes que un sistema REST aplica:
o La arquitectura cliente/servidor: La interfaz puede evolucionar de manera independiente con
respecto al servidor, y el servidor no se preocupa por la interfaz y estado de esta.
o Que es stateless: Es el No estado, indica que entre el cliente y el servidor no existe contexto
o Cacheability: Habla de que algunas respuestas puedan ser almacenadas en cache.
o El sistema puede estar basado en capas: El servidor debe estar compuesto de distintas capas
como las de presentación, datos e información.
o Que posee una interfaz uniforme: Estándar para la interfaz de comunicación entre el cliente
y servidor.
o Pueden enviar código On Deman (opcional): el servidor puede enviar scripts de código.
¿Cúando se usa?
Rest se aplica cuando se necesita manipular y realizar operaciones sobre datos que están
almacenados en una base de datos, permite la separación entre cliente servidor por ende otorga
escalabilidad si deseamos enfocarnos en el lado servidor, posee una gran comunidad con amplia
documentación, se apoya en HTTP generando una petición Request que solo espera un response y
este ofrece los métodos post, el ingreso de datos o recursos, get, para la recepción del recurso, put,
para actualizar el recurso y delete para eliminarlo.
¿Cómo se configura y se instala?
Teniendo en cuenta que REST hace alusión a las acciones de post, get, put y delete. Primero es
necesario instalar ciertos paquetes.
o Paquete Node (npm init -f)
o Paquete express (npm install express)
o Paquete mysql (npm install mysql)
o Paquete cors (npm install cors)
o Una vez instalados llamar al paquete y otorgarle una variable, procede a realizar la conexión
con la base de datos de preferencia y levantar el servidor.
o Definir los endpoints mediante consultas sql de get, post, delete y put.
1
Ilustracción 1: Arquitectura REST
3.2 API
¿Qué es?
Aplicattion Programing Interface o interfaz de programación de aplicaciones, son reglas de como
una aplicación puede comunicarse con otra, los datos se encuentran en el servidor y mediante un
API se accede a ellos desde la aplicación.
Existen distintos API:
o API´s de servicios web: Permite el intercambio de información entre un servidor y cliente
mediante el uso del protocolo http, la información será transferida en un formato xml o json.
o API’s de bibliotecas: Permite hacer uso de funciones, métodos o rutinas mediante una
biblioteca que deberá ser importada a la aplicación como por ejemplo el API de Google
maps para Java Script.
o API’s basadas en clases: Permite hacer uso de clases ya definidos que poseen ya una lógica
de programación para agilizar el proceso de desarrollo de software como la API de Java, que
son clases organizadas en paquetes.
o API’s de sistemas operativos: Permite que los programas interactúen con el sistema de tal
manera que se pueda tener acceso como el teclado, mouse, la interfaz gráfica, etc.
¿Cúando se usa?
Una API se aplica cuando es necesaria la comunicación entre dos aplicaciones sin necesidad que
ambas sean conscientes entre ellas, buscando que la programación no se inicie desde cero.
¿Cuáles son las ventajas de usarlo?
Entre las ventajas de una API encontramos:
Facilita el desarrollo de software, ahorra tiempo, le otorga flexibilidad y simplifican el diseño. Por
otro lado, también permiten mantener la seguridad y control, porque tienes la decisión de a quien se
le habilita y otorga el permiso.
¿Cómo se configura e instala?
Se definen los distintos endpoint mediante una función los cuales usaran get, post, put y delete, el
cual pide un Request y enviara un response.
Se define las consultas SQL, las cuales pueden ser escritas directamente en el código (poco
recomendable) o definir procedimientos en MySQL, los cuales serán almacenados en variables en
el código.
2
Ilustración 2: Código de endpoint de POST
4. EXPERIENCIAS DE PRÁCTICA
4.1 Crear el entorno del proyecto
a) HACER LAS INSTALACIONES DE PAQUETES:

1. Crear una carpeta para el proyecto con el nombre elegido para tal caso.
2. Acceder a la carpeta del proyecto para proceder a las instalaciones.
3. Crear el package.json el proyecto ejecutando la instrucción siguiente:
npm init -f
4. Instalar el paquete Express.JS con la siguiente instrucción:

npm i express
5. Instalar el componente MySql con la siguiente instrucción:

npm i express mysql
6. Instalar el paquete body-parser:

npm install body-parser
3
b) VERIFICAR LA INSTALACIÓN DE LOS PAQUETES:

1. Abrir el VS Code con la siguiente instrucción:
code .
2. Verificar la instalación y configuración dentro del package.json de los
paquetes que se instalaron, deben aparecer como en la siguiente figura:
c) CREAR UNA BASE DE DATOS:1

1. Ejecutar el WorkBench de mysql
2. Crear una Base de Datos bajo el nombre de barbershop
3. Crear una tabla books
4. Agregar los campos que crean necesarios
5. Insertar registros con Datos a la tabla books
4
d) CREANDO UN ARCHIVO INDEX.JS:

1. Crear el archivo index.js
2. Agregar los objetos que dependen de los paquetes instalados:
3. Agregar la conexión a la base de Datos:
-------------------------------------------------------------------------------
Index.js
//conectar a la base de datos
var mysqlConnection = mysql.createConnection(
{
host: 'localhost', //host
port: '33065', //puerto
user: 'root', //usuario
password: '', //contraseña
database: 'barbershop', //base de datos
}
);
-------------------------------------------------------------------------------
4. Agregar la función que verifica la conexión a la base de Datos:

-------------------------------------------------------------------------------
Index.js
//Test de conexion a la base de datos
mysqlConnection.connect((err)=>{
if(!err){
console.log(' exitosa Conexion');
} else {
console.log(' Error al conectar con la BD ' + err.stack);
}
});
-------------------------------------------------------------------------------
5. Agregar el código que convierte los registros de las tablas de la tabla a

formato json.
-------------------------------------------------------------------------------
5
Index.js
//agregando codigo que convierte los registros de las tabla a formato json.
app.use(bp.json());
app.use(bp.urlencoded({
extended: true,
}));
-------------------------------------------------------------------------------
6. Crear el servidor Node.js dentro de la aplicación:
-------------------------------------------------------------------------------
Index.js
//crear el servidor
var server = app.listen(3000,"127.0.0.1",function(){
var host = server.address().address
var port = server.address().port
});
-------------------------------------------------------------------------------
7. Crear el api que extrae Los registros de la tabla:
-------------------------------------------------------------------------------
Index.js
//API que trae todos los books
app.get('/books',function(req,res){
//res.send('ok');
mysqlConnection.query('select * from books',function(error,result){
if(error) throw error;
res.end(JSON.stringify(result))
});
});
-------------------------------------------------------------------------------
8. Ejecutar el programa en el terminal:
4.2 Verificando los registros extraídos
a) UTILIZANDO POSTMAN:
1. Ejecutar el programa postman o de lo contrario entrar a la página web loguearse y utilizarlo desde
la internet.
6
2. Escribir la dirección web de nuestra aplicación en la Barra de direcciones de postman y hacer

click en el botón SEND:
3. El programa extraerá todos los registros de la tabla de la base de Datos:
4. Puede cambiarlo a formato json para visualizarlo bajo formato clave-valor:

5. Puede visualizar que el estado del servidor está bajo el código 200 ok:
7
b) EXTRAER UN SOLO REGISTRO:

1. Agregar el siguiente código para extraer un registro mediante su ID:
-------------------------------------------------------------------------------
Index.js
//API que recupera dependendiendo del ID
app.get('/books/:id',function(req,res){
mysqlConnection.query('select * from books where id =?',
[req.params.id], function (error, results) {
if(error) throw error;
res.end(JSON.stringify(results))
});
});
-------------------------------------------------------------------------------
2. Ir a postman y verificar el funcionamiento del último método recuperando otra vez del id del
registro:
8
3. Cambia a formato json:
4. Crear un nuevo esquema para un procedimiento almacenado:
9
5. Crear un procedimiento almacenado para listar los libros:
6. Ingresar el siguiente procedimiento almacenado:
10
c) CREAR CON PROCEDIMIENTOS ALMACENADOS:

1. Crear una carpeta para el proyecto con el nombre elegido para tal caso.
2. Acceder a la carpeta del proyecto para proceder a las instalaciones.
3. Crear el package.json el proyecto ejecutando la instrucción siguiente:
npm init -f
4. Instalar el paquete Express.JS con la siguiente instrucción:
npm i express
5. Instalar el componente MySql con la siguiente instrucción:
npm i mysql
6. Instalar el paquete cors:
npm i cors
7. Instalar el paquete bodyparser:
npm i body-parser
11
8. Ejecutar VS Code y crear un nuevo proyecto.

9. Verificar la instalación de los paquetes.
d) CREAR :
1. Crear la carpeta config y dentro de la misma el archivo connection.js y agregar el siguiente código:
Config < connection.js

-----------------------------------------------------------------------
//constante para la variable mysql2
const mysql = require('mysql2');
//conexion
{
host: 'localhost',
port: '33065',
user: 'root',
password: '',
database: 'biblioteca',
}
);

if(!err){
} else {
}
12
});
//exportando el modulo
module.exports = mysqlConnection;
-----------------------------------------------------------------------
2. Agregar la carpeta routes y en ella el archivo books.js e ingresar el siguiente código:
Routes < books.js

-----------------------------------------------------------------------
//constante para la variable express
const express = require('express');
const appRouter = express.Router();
const con = require("../config/connection");
//constante para el paquete de bodyparser

const bodyParser = require("body-parser")
appRouter.use(bodyParser.urlencoded({extended: true}));
appRouter.use(bodyParser.json());
//llamando al procedimiento
let sql_all = 'call ups_listar_books()';
//ruta en libros, llamar al procedimiento

appRouter.get('/books',(req,res)=> {
con.query(sql_all,(error,results)=>{
if (error) {
throw error;
}
res.send(results);
})
});
module.exports = appRouter;
-----------------------------------------------------------------------
3. En la carpeta del proyecto agregar el archivo app.js y agregar el siguiente código:
app.js
-----------------------------------------------------------------------
//variable express
const app = express();
const cors = require('cors');
app.use(cors());
//escucha del servidor

app.listen('3000',() => {
console.log('Servidor en ejecucion');
})
//constante para la ruta

const bookRouter = require('./routes/books');
app.use('/api',bookRouter);
-----------------------------------------------------------------------
4. Ejecutar postman y cargar la dirección de la app y verificar que devuelve la data:
13
e) AGREGAR OTRO ENDPOINT:

1. agregar a la línea 11 del archivo books.js la siguiente línea:
//procedimientos
let sql_all = 'call ups_listar_books()';
let sql_insert = 'call ups_listar_books()';
2. Al final del archivo y antes del export agregar el nuevo endpoint:

books.js
-----------------------------------------------------------------------
//nuevo endpoint
appRouter.post('/books' ,(req,res) => {
const book = {
title = req.body.book_tittle,
author = req.body.book_author,
publicado = req.body.book_published
}
con.query(sql_insert,[book.title,book.author,book.publicado]
,(error,results) => {
if (error) {
throw error;
}
res.send(results);
})
});
-----------------------------------------------------------------------
14
3. Usar el postman para insertar un registro en la tabla usando el procedimiento almacenado:
4.3 USAR JWT

index.js
const jwt = require('jsonwebtoken');
app.get('/api',(req,res) => {
res.json({
mensaje:"Uso de JWT y Express. Desarrollo de Aplicaciones"
});
});
app.post('/api/login', (req,res)=>{
const user = {
id:2020245441,
username:"Joseph",
email:"joseph.ordonez@ucsm.edu.pe"
}
jwt.sign({user}, 'secretkey', {expiresIn : '60s'}, (err,token) => {

res.json({
token
});
});
});
app.post('/api/posts', verifyToken,(req,res)=>{
jwt.verify(req.token, 'secretkey', (err,authData)=>{
if(err){
res.sendStatus(403);
}else{
res.json({
mensaje:"Post creado...",
authData
15
});
}
})
});
function verifyToken(req,res,next){
const bearerHeader = req.headers['authorization'];
if (typeof bearerHeader !== 'undefined'){

const bearerToken = bearerHeader.split(' ')[1];
req.token = bearerToken;
next();
}else{
}
}
app.listen(5000,() => {console.log("Servidor iniciado en

http://localhost:5000")});
16
5. EJERCICIOS
5.1 Ejercicio 1
Creación de una base de datos llamada entradasconcierto, con su respectiva tabla

llamada entradas:
Ingreso de valores predeterminados en la tabla
INSERT INTO entradas(numAsiento,precio,tipoEntrada) VALUES

(‘B-01’,320.23,’Platinum’),
(‘L-11’,120.10,’General’),
(‘A-01’,510.01,’VIP’),
(‘C-01’,319.09,’Golden’);
Creación de procedimiento para visualizar
DELIMITER //
CREATE PROCEDURE ver_entradas()
BEGIN
SELECT * FROM entradas;
END
//
Creación procedimiento para mostrar todos los datos de un solo registro
DELIMITER //
CREATE PROCEDURE verUnaEntrada (in val int)
BEGIN
SELECT * FROM entradas WHERE id = val;
END;
//
Creación de procedimiento para ingresar datos
DELIMITER //
17
CREATE PROCEDURE insertarEntrada(

asiento Varchar(4),
prec float,
tipo Varchar(8))
BEGIN
INSERT INTO entradas(numAsiento, precio, tipoEntrada) VALUES (asiento,
prec, tipo);
END;
//
Crear procedimiento para actualizar o editar
DELIMITER //
CREATE PROCEDURE actualizarEntrada(
asiento varchar(4),
prec float,
tipo varchar(8),
cod int)
BEGIN
UPDATE entradas SET numAsiento = asiento, precio = prec, tipoEntrada =
tipo WHERE id = cod;
END
//
Crear procedimiento para eliminar
DELIMITER //
CREATE PROCEDURE eliminarEntrada(
cod int
)
BEGIN
DELETE FROM entradas WHERE id = cod;
END;
//
*******************************************************************************
connection.js
-------------------------------------------------------------------------------
//variable para mysql
var mysql = require('mysql');

{
host: 'localhost',
port: '33065',
user: 'root',
password: '',
database: 'entradasconcierto',
}
);

if(!err){
} else {
}
});
18
module.exports = mysqlConnection;
*******************************************************************************
App.js
-------------------------------------------------------------------------------
//variable para express
var express = require('express');
//variable app tipo expres
var app = express();
//indicar el uso de json
app.use(express.json());
const mysqlConnection = require("../config/connection");

//procedimientos
let sql_ver = 'call ver_entradas()';
let sql_verUna = 'call verUnaEntrada(?)';
let sql_insert = 'call insertarEntrada(?,?,?)';
let sql_edit = 'call actualizarEntrada(?,?,?,?)';
let sql_delete = 'call eliminarEntrada(?)';
//visualizar todas las entradas

app.get('/api/entradas',(req,res)=>{
mysqlConnection.query(sql_ver, (error, filas) =>{
if(error){
throw error;
} else {
res.send(filas);
}
})
});
//visualizar una entrada
app.get('/api/entradas/:id',(req,res)=>{
mysqlConnection.query(sql_verUna,[req.params.id],(error, fila) =>{
if(error){
throw error;
} else {
res.send(fila);
}
})
});
//Ingresar una entrada
app.post('/api/entradas',(req, res)=>{
let data =
{numAsiento:req.body.numAsiento,precio:req.body.precio,tipoEntrada:req.body.tip
oEntrada};
mysqlConnection.query(sql_insert,[data.numAsiento,data.precio,data.tipoEntrada]
, function(error,results){
if(error){
throw error;
} else {
res.send(results);
}
});
});
//metodo para editar
19
app.put('/api/entradas/:id',(req,res)=>{
let id = req.params.id;
let numAsiento = req.body.numAsiento;
let precio = req.body.precio;
let tipoEntrada = req.body.tipoEntrada;
mysqlConnection.query(sql_edit, [numAsiento, precio, tipoEntrada, id],

function(error, results){
if(error){
throw error;
} else {
res.send(results);
}
});
});
//metodo para eliminar entrada
app.delete('/api/entradas/:id', (req,res)=>{
mysqlConnection.query(sql_delete,[req.params.id], function(error,filas){
if(error){
throw error;
} else {
res.send(filas);
}
});
});
app.listen('3000', function() {
console.log('Servidor funcionando...');
})
*******************************************************************************
OPERACION GET EN POSTMAN
GET: localhost/3000/api/entradas
20
OPERACION GET EN POSTMAN

GET: localhost/3000/api/entradas/3
OPERACION POST EN POSTMAN

POST: localhost/3000/api/entradas
OPERACION PUT EN POSTMAN

PUT: localhost/3000/api/entradas/3
21
OPERACION DELETE EN POSTMAN

DELETE: localhost/3000/api/entradas/5
5.2 Ejercicio 2
index.js
const jwt = require('jsonwebtoken');
// endpoint
app.get('/api',(req,res) => {
res.json({
mensaje:"Uso de JWT y Express. Desarrollo de Aplicaciones"
});
});
// 1er endpoint login

22
app.post('/api/login', (req,res)=>{
const user = {
id:2020245441,
username:"Joseph",
email:"joseph.ordonez@ucsm.edu.pe"
}
jwt.sign({user}, 'secretkey', {expiresIn : '60s'}, (err,token) =>

{
res.json({
token
});
});
});
// 2do endpoint login

app.post('/api/practica12', (req,res)=>{
const user = {
id:12,
username:"Practica12",
descripcion:"Desarrollo de Aplicaciones"
}
jwt.sign({user}, 'secretkey', {expiresIn : '60s'}, (err,token) =>

{
res.json({
token
});
});
});
// endpoint
app.post('/api/posts', verifyToken,(req,res)=>{
jwt.verify(req.token, 'secretkey', (err,authData)=>{
if(err){
}else{
res.json({
mensaje:"Endpoint",
authData
});
}
})
});
function verifyToken(req,res,next){
const bearerHeader = req.headers['authorization'];
if (typeof bearerHeader !== 'undefined'){

const bearerToken = bearerHeader.split(' ')[1];
req.token = bearerToken;
next();
}else{
23
}
}
app.listen(5000,() => {console.log("Servidor iniciado en
http://localhost:5000")});
24
6. CONCLUSIONES DE LA PRÁCTICA:
a) A partir de la elaboración de la experiencia práctica pudimos comprender que la implementación
de una arquitectura REST, actualmente es crucial para cualquier tipo de aplicación relacionada
con la manipulación de datos, es decir, la gran mayoría de las aplicaciones desarrolladas
actualmente y en el futuro utilizarán esta estructura. Por ende, este tema es crucial de aprender
para todo aquel enfocado en el desarrollo de aplicaciones web.
b) Por otro lado, al realizar la API REST, se pudo apreciar la importancia de NO aplicar SQL
dentro del código, dado que originara problemas de seguridad a largo plazo, en su lugar la
llamada a procedimientos que fueron previamente definidos en la base de datos es la mejor
opción para un desarrollo de API REST óptimo.
c) Durante el desarrollo de la practica pudimos notar la importancia de la comunicación entre los
componentes de software, el proceso que siguen las llamadas y los elementos que establecen el
proceso del funcionamiento de una API.
d) Una API RESTful permite la conectividad entre piezas de software y utiliza las peticiones HTTP
para realizar operaciones siguiendo un estándar.
e) Para que las empresas trabajen juntas sin codificar a mano los enlaces de afiliados, deben
estandarizar su modelo de gobierno en lugar de invertir en sus propios sistemas. REST
proporciona un alto nivel de estandarización. Por lo tanto, si los servicios web basados en SOAP
no implementan este mecanismo, fallarán, marcando el comienzo de la era de los servicios web
basados en REST.
f) La exposición de los recursos del sistema a través de la API REST es muy flexible, por lo que
la información se puede entregar a diferentes aplicaciones en diferentes formatos. REST ayuda
a cumplir con los requisitos de integración que son críticos en la construcción de sistemas donde
los datos se pueden combinar y ampliar fácilmente. Desde esta perspectiva, los servicios REST
se convierten en algo mucho más grande.
7. CUESTIONARIO
1. ¿Qué se entiende por Servicios Web RESTful?

Se comprende como al servicio web que aplica la arquitectura REST dentro de su desarrollo
y son las URLs su elemento principal en las cuales se basan. [1]
2. ¿Qué es un recurso REST?
Se dice de aquello que es direccionable mediante la Web, es decir que se pueden acceder y
transferir entre cliente y servidor.
3. ¿Qué es un URI?
Conocido como Uniform Resource Identifier, es el único medio para intercambiar una
representación entre cliente y servidor.
4. ¿Cuáles son las características de los Servicios Web RESTful?
La aplicación de un servicio Web RESTful está centrado en el intercambio de los recursos,
estos le permitirán modificar el estado de un dato, existen las siguientes acciones que se
pueden realizar sobre ellos: create, retrieve, update y delete.
5. ¿Qué es el concepto de statelessness en REST?
Indica que REST no tiene estado, es decir que no existe la necesidad por ejemplo de que se
guarde una sección de usuario, además que cada petición presenta independencia frente a las
demás.
6. ¿Qué son los códigos de estado HTTP?
Es el mensaje que envía el servidor correspondiente a la solicitud, por ejemplo, un código 200
25
es igual a un OK. Encontramos cinco rangos, entre 1xx es información, 2xx está relacionado
al éxito, 3xx corresponde a la redirección, 4xx será un error de cliente y 5xx un error del
servidor.
7. ¿Qué son los métodos HTTP?
Encontramos los métodos de GET o RETRIEVE, permite recuperar los recursos, el método
de POST o CREATE, permite crear recursos, el método PUT o UPDATE, permite alterar los
recursos para modificarlos y el método DELETE que permite eliminar al recurso.
8. ¿Puede indicar las desventajas de los servicios web RESTful?
Se puede tener más de un servidor, pero estos no se reconocen entre sí, no se tiene
conocimiento de los usuarios que inician sesión o los datos que se le entregaron, ni tampoco
se tiene seguimiento de la solicitud evitando saber en qué servidor cayo. [2]
9. Defina la mensajería en términos de servicios web RESTful.
Encontramos dos puntos, el cliente y el servidor, ambos se comunicarán mediante una API, el
mensaje sale del cliente, llega al servidor y si es recibido correctamente, vuelve a salir hacia
el otro cliente.
10. ¿Diferencia entre SOAP y REST?
SOAP REST
- Es un protocolo para implementar en el - Es una arquitectura de diseño para el
servicio web. desarrollo de servicios web.
- Un criterio se debe cumplir - Un criterio no es necesario cumplirlo
obligatoriamente. completamente.
- Admite la transferencia únicamente de - Se puede transferir XML, JSON, MIME,
XML etc.
- Una lectura no se almacena en el cache. - Se puede almacenar la consulta en el
- Es más lento cache.
- Tiene sus propios protocolos de seguridad. - Es más rápido.
- Utilizado cuando los datos requieren ser - Solo tomara precauciones de seguridad.
transportados con estado y mayor - Ofrece la escalabilidad y fácil
confiabilidad. mantenimiento.
11. Al crear URI para servicios web, ¿cuáles son las mejores prácticas que se deben seguir?
Se deberían seguir los siguientes puntos:
El URI debe estar estructurado de una forma comprensible y de fácil entendimiento para el
cliente y servidor
La representación ha de ser completa independientemente de su estructura, si existe una
vinculación con otros recursos, estos también deben ser considerados y manejados.
12. ¿Cuáles son las mejores prácticas para desarrollar servicios web RESTful?
Se deben seguir los siguientes puntos:
La entrada al servidor debe ser validadas, cada una de ellas, se deben encontrar bien formadas,
no deben pasar datos sensibles mediante la URL, debe existir la autenticación, uso de error
HTTP para las fallas, el URI debe ser fácil de comprender.
13. ¿Qué son los métodos idempotentes? ¿Cuál es su relevancia en el ámbito de los servicios web
RESTful?
Cuando se envía el mismo URI, habrán algunos métodos HTTP que generaran el mismo
resultado en el servidor, por ejemplo, el método GET.
Estos métodos son importantes porque garantizan la coherencia en las actividades.
14. ¿Cuáles son las diferencias entre REST y AJAX?
REST AJAX
El elemento XMLHttpRequest se usa para Se utilizan recursos para formar una URI y
las solicitudes direccionadas al el request/response.
26
servidor y será el JavaScript quien El usuario solicita datos utilizando REST

otorga la respuesta. Necesita comunicar al cliente y al servidor.
Esta permite actualizar dinámicamente la
interfaz.
No existe una comunicación asíncrona entre
cliente y servidor.
15. ¿Puede decir cuáles son los componentes principales de la solicitud HTTP?
Existirá un verbo correspondiente al método GET, PUT, POST, DELETE.
El URI para identificar al recurso disponible
La versión HTTP para especificar la versión.
El encabezado de la solicitud
Cuerpo de la solicitud
16. ¿Cuáles son los componentes principales de la respuesta HTTP?
Se encuentra compuesto de cuatro componentes:
El código de estado es el código que enviara el servidor en respuesta a la solicitud del recurso.
La versión HTTP, la versión de http indica la versión del protocolo.
Encabezado de la respuesta, aquí se haya al metadato, indica cosas como la fecha de respuesta,
etc.
Cuerpo de la respuesta, se haya el recurso que el servidor devuelve.
17. Defina el direccionamiento en términos de servicios web RESTful.
Debe contar con una interfaz uniforme, las direcciones contaran con una única dirección y
punto valido de acceso.
18. ¿Cuáles son las diferencias entre PUT y POST en REST?
PUT: Este permite alterar el recurso que ya existe mediante un identificador y es idempotente.
POST: Enviara el recurso al URI, será el servidor quien decida que realizar con los datos que
recibe, no es idempotente.
19. ¿Qué hace que los servicios REST sean fácilmente escalables?
El hecho de que sean stateless o sin estado, permiten que las solicitudes se distribuyan de
manera más sencilla entre los diferentes servidores.
20. ¿Qué es un JSON Web Token?
Este es un estándar, mecanismo que permite propagar entre dos lados de una forma segura,
aplicando privilegios que se encuentran de codificados en JSON, los cuales se encontraran
dentro de un payload que ira firmada de manera digital.
21. ¿Cuándo se deben utilizar los JSON Web Token?
Sirven para comunicar dos partes de la identidad de un usuario, permitiría la implementación
de una autenticación de usuario de una forma más segura.
22. ¿Cuál es la estructura de los JSON Web Token?
Esta formado de tres partes:
El header, donde se indicará el algoritmo y el tipo de token.
El payload, será el lugar donde se presenten los datos del usuario, sus privilegios y demás
información.
El signature, esta firma confirmara que el token sea válido.
23. ¿Cómo funcionan los JSON Web Token?
Validara la identidad de quien ingresa a la página, una vez que haya ingresado con anterioridad
a su inicio de sesión, haciendo que el login no sea necesario cada vez.
24. ¿Cómo funciona un JSON Web Token?
Este se encuentra firmado de manera digital y verificara la identidad del usuario.
27
25. ¿Por qué debemos utilizar los JSON Web Token?

Aplicados para mantener una autenticación de usuario más segura.
8. BIBLIOGRAFÍA
[1] ua, «Introducción a los Servicios Web RESTful,» [En línea]. Available:
http://www.jtech.ua.es/j2ee/restringido/cw/sesion11-apuntes.pdf. [Último acceso: 24
Noviembre 2022].
[2] Desarrollo Web, «Ventajas e inconvenientes de API REST para el desarrollo,» 19 Diciembre
2014. [En línea]. Available: https://desarrolloweb.com/articulos/ventajas-inconvenientes-
apirest-
desarrollo.html#:~:text=Desventajas%20del%20desarrollo%20basado%20en%20REST&tex
t=En%20un%20esquema%20REST%20puedes,servidor%20puede%20caer%20una%20solic
itud.. [Último acceso: 24 Noviembre 2022].
28

Modelo de Informe Practica #12 - 2022

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Modelo de Informe Practica #12 - 2022

Cargado por

Copyright:

Formatos disponibles

UCSM Esc. Prof.

de Ingeniería de Sistemas INFORME DE PRÁCTICAS

Práctica N° 12: Servicios Rest Node JS

© IEEE 2013 The Institute of Electrical and Electronics Engineers, Inc.

PRÁCTICAS DE DESARROLLO DE APLICACIONES

Node JS y Express, REST, API, Postman, Json, Token.

ÍNDICE DE TABLAS Y FIGURAS

Ilustracción 1: Arquitectura REST

Ilustración 2: Código de endpoint de POST

a) HACER LAS INSTALACIONES DE PAQUETES:

4. Instalar el paquete Express.JS con la siguiente instrucción:

5. Instalar el componente MySql con la siguiente instrucción:

6. Instalar el paquete body-parser:

b) VERIFICAR LA INSTALACIÓN DE LOS PAQUETES:

c) CREAR UNA BASE DE DATOS:1

d) CREANDO UN ARCHIVO INDEX.JS:

4. Agregar la función que verifica la conexión a la base de Datos:

5. Agregar el código que convierte los registros de las tablas de la tabla a

6. Crear el servidor Node.js dentro de la aplicación:

7. Crear el api que extrae Los registros de la tabla:

8. Ejecutar el programa en el terminal:

4.2 Verificando los registros extraídos

2. Escribir la dirección web de nuestra aplicación en la Barra de direcciones de postman y hacer

3. El programa extraerá todos los registros de la tabla de la base de Datos:

4. Puede cambiarlo a formato json para visualizarlo bajo formato clave-valor:

b) EXTRAER UN SOLO REGISTRO:

3. Cambia a formato json:

4. Crear un nuevo esquema para un procedimiento almacenado:

5. Crear un procedimiento almacenado para listar los libros:

6. Ingresar el siguiente procedimiento almacenado:

c) CREAR CON PROCEDIMIENTOS ALMACENADOS:

8. Ejecutar VS Code y crear un nuevo proyecto.

Config < connection.js

//Test de conexion a la base de datos

Routes < books.js

const con = require("../config/connection");

//constante para el paquete de bodyparser

//ruta en libros, llamar al procedimiento

//escucha del servidor

//constante para la ruta

e) AGREGAR OTRO ENDPOINT:

2. Al final del archivo y antes del export agregar el nuevo endpoint:

3. Usar el postman para insertar un registro en la tabla usando el procedimiento almacenado:

4.3 USAR JWT

jwt.sign({user}, 'secretkey', {expiresIn : '60s'}, (err,token) => {

if (typeof bearerHeader !== 'undefined'){

app.listen(5000,() => {console.log("Servidor iniciado en

Creación de una base de datos llamada entradasconcierto, con su respectiva tabla

Ingreso de valores predeterminados en la tabla

INSERT INTO entradas(numAsiento,precio,tipoEntrada) VALUES

Creación de procedimiento para visualizar

Creación procedimiento para mostrar todos los datos de un solo registro

Creación de procedimiento para ingresar datos

CREATE PROCEDURE insertarEntrada(

Crear procedimiento para actualizar o editar

Crear procedimiento para eliminar

//conectar a la base de datos

//Test de conexion a la base de datos

const mysqlConnection = require("../config/connection");

//visualizar todas las entradas

//Ingresar una entrada

//metodo para editar

mysqlConnection.query(sql_edit, [numAsiento, precio, tipoEntrada, id],