Creación de una base de datos en Azure, modificación del API para trabar con DB y vinculación con el API
Creación de un Servidor en Azure
Para hacer la creación de un servidor de Azure, lo primero que tenemos que hacer es tener una cuenta en portal.azure.com. Yo por ejemplo, creé mi cuenta con mi correo estudiantil, el cual me otorga $100 dólares para poder ocupar en los servicios de Azure.
Una vez con nuestra cuenta logueada, vamos a poner en el buscador "Servidores de Azure Database for MySQL" y haremos clic en este que aparece en la imagen
Nos aparecerá la siguiente venta y haremos clic en "Crear Azure Database para el servidor MySQL"
Nos aparecerá una ventana como la siguiente y vamos a seleccionar en el apartado Tipo de recurso la opción de "Servidor flexible" y vamos a dar clic en "crear"
Configuración del servidor
Se nos abrirá una ventana en donde realizaremos las siguientes configuraciones.
Detalles del proyecto
En este apartado seleccionaremos "Azure for Students" en el apartado de Suscripción y en Grupo de recursos seleccionaremos "DemoWeb", el cual ya habíamos creado con anterioridad en la sección 4 de este tutorial.
Detalles del servidor
Asignaremos el Nombre del servidor, en este caso yo le pondré por nombre "rest-api-server", las demás configuraciones las colocaremos como se muestra en la imagen, y haremos clic en "Configurar servidor"
Se nos abrirá otra ventana
NOTA IMPORTANTE: CREAR UN SERVIDOR DE ESTE TIPO TIENE UN COSTO MENSUAL, NOSOTROS LO VAMOS A CONFIGURAR TRATANDO DE HACERLO LO MAS ECONÓMICO POSIBLE, COMO SOLO ES UN PROYECTO CON FINES DE APRENDIZAJE, NO NECESITAMOS MUCHOS RECURSOS. AUN ASÍ, TE VOY A COMPARTIR ESTE PROYECTO FUNCIONANDO PARA QUE TU PUEDAS REALIZAR TUS PROPIAS PRUEBAS, SI LO REVISAS DESPUES DE UN AÑO A PARTIR DE QUE SE REALIZÓ ESTE PROYECTO (02/06/2022) ES PROBABLE QUE LOS CREDITOS QUE NOS PROPORCIONÓ AZURE YA ESTÉN VENCIDOS Y POR LO TANTO EL SERVIDOR YA NO ESTÉ ACTIVO
Proceso
En este apartado solo modificaremos el Tamaño de proceso y seleccionaremos la opción "Standard_B1s(1 núcleo virtual, 1 memoria GiB, 400 IPOS máxima)"
Almacenamiento
En Storage size (in GiB) Seleccionaremos "20" y en IOPS pondremos "360"
Y listo, las demás configuraciones las dejaremos por defecto. Y haremos clic en "Guardar"
¡Podemos observar que conseguimos hacer un poco más barato el costo del servidor!
Cuenta de administrador
Por último, vamos a configurar el usuario de nuestro servidor para poder acceder a éste.
En Nombre de usuario de administrador vamos a colocar un nombre para nuestro administrador, en este caso voy a colocar "root1" y vamos a crear una contraseña. Y haremos clic en " Siguiente".
Es importante guardas estos datos porque los vamos a estar utilizando más adelante para poder conectarnos a nuestro servidor
Redes
En esta ventana bajaremos hasta el apartado "Reglas de firewall"
Reglas de firewall
Vamos seleccionar la opción "Permitir” acceso público a este servidor desde cualquier servicio de Azure dentro de Azure" y hacer clic en "+ Agregar dirección IP del cliente actual"
Nos aseguramos de que se haya agregado en la tabla de abajo
Las demás configuraciones las dejaremos por defecto y haremos clic en "Revisar y crear"
Nos aparecerá una venta como esta y haremos con en "crear"
Posteriormente la implementación de nuestro servidor comenzará, aquí debemos esperar unos minutos a que termine la implementación
Una vez terminada la implementación, nos aparecerá una ventana como la siguiente, y haremos clic sobre " Ir al recurso"
Des habilitación de la aplicación de SSL
La siguiente información fue sacada directamente de la documentación de Microsoft
*"El servidor flexible de Azure Database for MySQL admite la conexión de las aplicaciones cliente al servidor MySQL mediante el cifrado de la Capa de sockets seguros (SSL) con la Seguridad de la capa de transporte (TLS). TLS es un protocolo estándar del sector que garantiza conexiones de red cifradas entre el servidor de bases de datos y las aplicaciones cliente, lo que le permite ajustarse a los requisitos de cumplimiento.
Si la aplicación cliente no admite conexiones cifradas, tendrá que deshabilitar la obligatoriedad de conexiones cifradas en el servidor flexible. Para deshabilitar la obligatoriedad de conexiones cifradas, debe establecer el parámetro de servidor require_secure_transport en OFF"*
Para más información acerca de SSL, te invito a pasar a la página de Microsoft para que te informes mas LINK
Como ya lo leyeron arriba, nuestra aplicación cliente no va a admitir conexiones cifradas, por lo tanto tenemos que deshabilitarlas, para esto dentro del recurso de nuestro servidor vamos a ir a la barra del lado izquierdo y buscaremos la opción Parámetros del servidor y haremos clic sobre éste
Se nos abrirá una ventana y en el buscador colocaremos "require_secure_transport", cambiaremos la opción a "OFF" y daremos clic en "Guardar"
Esperemos nuevamente que termine la implementación y una vez terminada, vamos a ir a la opción de la barra de lado izquierdo que dice "Información general" vamos a dar clic y se nos abrirá una ventana como esta: De aquí vamos a copiar el Nombre del servidor que es el que vamos a estar utilizando para poder conectarnos a nuestro servidor.
En este caso el enlace para el servidor que montamos es: rest-api-server.mysql.database.azure.com
estamos listo para crear nuestra base de datos!!!
Creación de base de datos y tabla
Una vez implementados nuestros cambios, vamos a hacer clic en " Ir al recurso" y una vez aquí, vamos a acceder a la terminal dentro de nuestro portal de Azure, para esto haremos clic sobre este icono ubicado en la parte superior de nuestra ventana
En la parte de abajo nos aparecerá una ventana como esta y haremos clic sobre " Crear almacenamiento"
Esperamos a que termine de cargar y finalmente nos aparecerá una ventana como esta:
¡Muy bien! Ahora sí estamos listos para crear nuestra base de datos.
Para crear nuestra base de datos tenemos dos opciones, usar la terminal que nos ofrece el propio portal de Azure, o hacer uso de MySQL Workbench. Nosotros en esta ocasión vamos a utilizar la terminal de Azure, pero si tu decides hacerla haciendo uso de MySQL Workbench, aquí te dejo la DOCUMENTACIÓN necesaria de parte de Microsoft para realizar la conexión
Para crear nuestra base de datos primero realizaremos la conexión al servidor con MySQL, para esto vamos a ingresar la siguiente línea de código en nuestra terminal, en donde host es el nombre del servidor (que copiamos anteriormente) y user el nombre del administrador que configuramos cuando creamos el servidor
mysql --host=rest-api-server.mysql.database.azure.com --user=root1 -p
Después nos va a pedir nuestra contraseña, aquí es muy importante notar, que vamos a escribir nuestra contraseña pero no se va a ver que estamos escribiendo, es decir el curso seguirá igual, pero en realidad sí estamos escribiendo. Una vez insertada nuestra contraseña correctamente vamos a presionar "enter" y nos aparecerá algo así
Para crear nuestra base de datos insertaremos el siguiente comando, donde "baseDeDatosDemoWeb" es el nombre que decidí para mi base datos, pueden sustituirlo por el nombre de su preferencia
create database baseDeDatosDemoWeb;
Vamos a recibir esta respuesta
Ahora debemos hacer uso de nuestra base de datos, para esto vamos a insertar el siguiente comando, en donde baseDeDatosDemoWeb, es el nombre de la base de datos que queremos utilizar:
USE baseDeDatosDemoWeb;
Vamos a recibir la siguiente respuesta
Una vez dentro de nuestra base de datos, vamos a crear dentro una tabla, para esto vamos a insertar el siguiente código. Aquí es muy importante que el nombre de los campo coincidan con los nombres que asignamos en el Schema de nuestra definición. Por otro lado "persona" es el nombre que decidí para la tabla, ustedes pueden poner el nombre de su preferencia.
CREATE TABLE personas (
id INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
Nombre VARCHAR(20),
Apellido VARCHAR(20),
Edad INT UNSIGNED,
Mail VARCHAR(40),
Celular BIGINT UNSIGNED
);
Vamos a recibir la siguiente respuesta:
Y ahora vamos a insertar unos datos de forma manual, para tener algo con que comenzar, posteriormente todo lo haremos directamente desde nuestro REST-API.
Para insertar los datos vamos a escribir el siguiente código en nuestro terminal
INSERT INTO personas (Nombre, Apellido, Edad, Mail,Celular) VALUES
('Roberto', 'Carlos', 25, 'roberto@correo.com', 2222222222),
('Carlos', 'Guzman', 24, 'carlos@correo.com',6666666666),
('Maite', 'Cruz', 23, 'maite@correo.com', 1111111111);
Recibiremos una respuesta como esta
Por último, verificamos los datos que introducimos, para esto utilizamos el comando
SELECT * from personas;
Recibiremos esta respuesta
¡¡Y ahora sí!! Tenemos nuestro servidor, nuestra base de datos y nuestra tabla trabajando perfectamente. Ahora lo que sigue es modificar nuestro código del API, para que pueda tener acceso a nuestro servidor
Cambios en el código de nuestro REST-API
Añadir dependencias
Como bien sabemos, anteriormente teníamos nuestra "base de datos" en un arreglo dentro de nuestra aplicación, pero como ahora sí tenemos una base de datos, a la cual conectar nuestro REST API, tenemos que hacer unos cambios en nuestro código para poder conectarnos e interactuar con ésta.
Antes de comenzar, debemos instalar en nuestro proyecto de VScode la dependencia de MySQL, lo cual vamos a hacer poniendo el siguiente comando en la terminal dentro de nuestro proyecto:
npm i mysql -s
Instalamos doteev que es una dependencia de node que carga las variables de entorno desde un archivo .env en process.env
npm i dotenv -s
Código
Vamos a partir de nuestro proyecto creado anteriormente, y simplemente haremos algunas modificaciones. Si no tiene el proyecto, aquí te dejo el repositorio para que vayas a descargarlo LINK
Abrimos nuestro proyecto en VSCode
En nuestro proyecto, en el mismo nivel que la carpeta app, vamos a crear un archivo nuevo y lo vamos a nombrar ".env" . También, nuevamente en el mismo nivel que la carpeta app vamos a crear una nueva carpeta, la cual nombraremos "config" y dentro de esta carpeta vamos a crear un archivo llamado "mysql.js" esto haciendo referencia a que nos servirá para la conexión con la base de datos de MySQL. Quedando al final de la siguiente forma, los archivos remarcados en color verde son los que acabamos de agregar:
Abrimos ahora el archivo .env, en este archivo van a ir todos los datos necesario para conectarnos a nuestra base de datos El archivo .env permite personalizar las variables de entorno de trabajo individuales. Puesto que el archivo .env está oculto El uso de variables de entorno, o environment, en las aplicaciones web es importante para la separación del código por responsabilidades, no debemos mezclar el código de la aplicación con los valores de configuración.
Las variables de configuración cambiarán generalmente según el entorno de ejecución, es decir, cuando una aplicación está siendo ejecutada en distintos servidores.
Lo que es importante es que estos archivos no se encuentren al alcance de los usuarios, por lo que nunca deberían estar dentro de la carpeta de publicación, sino en algún directorio por encima en el servidor. Es decir, se colocará en la raíz del proyecto, pero nunca dentro de la carpeta raíz de publicación, pues si estuvieran allí los usuarios podrían acceder a esos valores componiendo la ruta como "example.com/.env". Obviamente, los valores de configuración deseamos que estén seguros, por lo que no deben ser accesibles por el público en general.
En este archivo ".env" vamos a agregar las siguientes líneas
DB_CONN=rest-api-server.mysql.database.azure.com
DB_USER=root1
DB_PASSWORD=rest-api246
DB_DATABASE=basededatosdemoweb
DB_PORT=3306
Se estarán preguntando de donde obtuve esos datos, para obtener los datos de la conexión a nuestra base de datos. Tenemos que ir al servidor que creamos anteriormente dentro Azure. Par eso tenemos que visitar portal.azure.com, ahí vamos a buscar nuestro servidor creado y daremos clic en éste
Nos desplegará una ventana y buscaremos en la barra lateral derecha el apartado de "Cadenas de conexión"
Aquí nosotros copiaremos por ejemplo la de Node.js
La cual nos dará algo como esto:
var conn=mysql.createConnection({
host:"rest-api-server.mysql.database.azure.com",
user:"root1",
password:"{your_password}",
database:"{your_database}",
port:3306,
ssl:{ca:fs.readFileSync("{ca-cert filename}")}});
Como nosotros no vamos a hacer la conexión directa, sino que vamos a hacer por medio de variables de entorno, entonces de aquí vamos a ir copiando los valores uno a uno e írselos asignado a las constantes que pusimos en el archivo ".env". Ahora recordemos que nosotros eliminamos la autenticación por SSL por lo que no es necesario agregar esa variable. Los campos password lo obtuvimos al momento de crear nuestro servidor, y database es el nombre de la base de datos que nosotros creamos.
Posterior a esto, en el archivo "mysql.js" que creamos vamos a pegar el siguiente código, este nos servirá para realizar la conexión con la BD
const mysql = require('mysql');//Utilizo el módulo de mysql p
//Creo una función para realizar la conexión de la base de datos
const dbConnect = () =>{
/*creo un objeto con los parámetros necesarios para realizar la conexión a la db, noten
que lo realizo con los valores que añadimos en el archivo .env*/
conn= mysql.createConnection({
host:process.env.DB_CONN,
user:process.env.DB_USER,
password:process.env.DB_PASSWORD,
database:process.env.DB_DATABASE,
port:process.env.DB_PORT
})
//con los datos del objeto, intentamos hacer la conexión a la base de datos
conn.connect(error=>{
// si hay error en la conexión
if(error) throw {error: "**** ERROR DE CONEXION ****"}
//si la conexión fue correcta
console.log("**** CONEXION CORRECTA ****");
})
}
//exportamos nuestra función para llamarla en el index
module.exports={dbConnect}
Y finalmente en el archivo index.js vamos a agregar en las cabeceras las siguientes líneas
require('dotenv').config()
const {dbConnect}=require('./config/mysql')// importamos la función dbConnect del archivo mysql.js
Y en la parte de hasta abajo, antes de realizar el app.listen al puerto vamos a agregar
//llamamos a la función que realiza la conexión con la DB
dbConnect()
Y así es, solo con tres líneas en nuestro índex, creamos la conexión a nuestra base de datos. De todas formas, el código completo en el archivo de index.js es el siguiente:
const express = require('express'); // Utilizo el módulo de express de Node
const path = require('path'); // Utilizo el módulo path de Node
const bodyParser = require('body-parser') // Utilizo el modulo de body parser
const app = express(); // Genero mi aplicación de express simplemente llamando al constructor express()
const endPoints = require('./app/routers/personas')/*Importo el modulo(en este caso endPoint) que exporte
desde la ruta ./app/routers/personas */
const cors = require('cors')//Utilizo el módulo de cors
require('dotenv').config()
const {dbConnect}=require('./config/mysql')// importamos la funcion dbConnect del archivo mysql.js
app.use(cors());//le damos acceso a nuestro API desde cualquier 'origen'
//Route "Pagina principal" al momento de conectarse al API, con un método GET que el navegador hace por default
app.get('/', (req, res)=>{
res.send("Bienvenido a mi API");
})
//Middleware
//Body Parser (Para pasar a json los endpoint tipo post), se ejecuta antes de llegar al siguiente Middleware
app.use(bodyParser.urlencoded({extended: true}));
app.use(bodyParser.json());
//Middleware (registra una ruta) y ejecuta lo que viene dentro de endPoints
app.use('/personas', endPoints)
/*Si tuvieramos otra ruta en nuestra api como por ejemplo '/objetos', debemos crear las respectivas hojas
de las carpetas controllers y routers con el mismo nombre 'objetos'*/
//llamamos a la función que realiza la conexión con la DB
dbConnect()
/* constante para nuestro puerto, es un una condición OR para el caso de desarrollo en algún servicio
o desarrollo local (nuestro caso) */
const port = process.env.port || 8080;
app.listen(port, () =>console.log(`Escuchando en el puerto ${port}`))
Guardamos los cambios y corremos nuestra aplicación, ya saben para esto en la terminal escribimos el comando
npm run serve
Y si todo sale bien, nos aparecerá en consola un mensaje como este, lo cual indica que hicimos una conexión correcta a nuestra base de datos
Ahora simplemente en nuestro archivo personas.j dentro de la carpeta de controllers, vamos a realizar algunas modificaciones, porque, recordemos que ya no vamos a hacer las solicitudes simplemente con un array interno, sino que las haremos directamente en la base de datos. En este archivo, cambiaremos el contenido de cada función, porque antes insertábamos datos en un array, ahora tenemos que cambiar esto por comandos y validaciones de SQL. El código que vamos a insertar es el siguiente. El código viene con sus respectivos comentarios para mayor entendimiento del mismo
const { response } = require('express');
const { request } = require('express');
//Obtener todas las personas de la lista
const obtenerPersonas = [(request, response)=>{
//creo el comando para seleccionar todas los elementos mi tabla personas y lo guardo en sql
const sql = 'SELECT * FROM personas';
//Hago la conexión con mi base de datos
conn.query(sql, (error, results) => {
//Si se genera un error con la bd lo lanzamos
if (error) throw error;
// Sino se genera error, verificamos que venga algo en la respuesta, es decir que el haya al menos una persona registrada
if (results.length > 0) {
/*Si existen personas,Mandamos todas las persona registradas en la respuesta,
aquí ya se realizó la sentencia de sql*/
response.json(results);
} else {
//Sino existe ninguna persona registrada imprimimos el mensaje:
response.status(415).json({error: "No existe ninguna persona registrada"});
}
});
}]
//Obtener una personas de la lista de acuerdo a su ID
const obtenerPersona =[(request,response)=>{
/*recupero el id de la persona haciendo un de-structur. La idea es crear una variable llamada id,
que está contenida con el mismo nombre id dentro de parms*/
const {id} = request.params
//creo el comando para seleccionar la persona con el id de mi tabla personas y lo guardo en sql
const sql = `SELECT * FROM personas WHERE id = ${id}`;
//Hago la conexión con mi base de datos
conn.query(sql, (error, results) => {
//Si se genera un error con la bd lo lanzamos
if (error) throw error;
// Sino se genera error, verificamos que venga algo en la respuesta, es decir que el id exista
if (results.length > 0) {
// Si el id existe, mandamos en la respuesta los datos de la persona, aquí ya se realizó la sentencia de sql
response.json(results);
} else {
//Sino existe el id imprimimos el mensaje:
response.status(410).json({error: "Este id no existe"});
}
});
}]
//Añadir una nueva persona a la lista
const añadirPersona = [(request,response)=>{
/*Todo esto se ejecuta solo si los datos fueron validados. Es decir, validarDatos dentro de
/validator/personas.js continuó con next()*/
//creo el comando para seleccionar para añadir una persona en mi tabla personas y lo guardo en sql
const sql = `INSERT INTO personas SET ?`
//Crea una variable de tipo objeto, llamada nuevaPersona, con los datos mandados en el body dentro de request
const nuevaPersona = {
Nombre: request.body.Nombre,
Apellido: request.body.Apellido,
Edad: request.body.Edad,
Mail: request.body.Mail,
Celular: request.body.Celular
}
//Hago la conexión con mi base de datos
conn.query(sql,nuevaPersona, (error) => {
//Si se genera un error con la bd lo lanzamos
if (error) throw error;
/* Sino se genera error, mando en mi respuesta los de la persona creada, aquí ya se realizó la
sentencia de sql,pero para mandar los datos de la persona creada primero solicito el id que le asignó
con el siguiente comando*/
sqlId ='SELECT @@identity AS id'
//Hago la conexión con mi base de datos
conn.query(sqlId,(error,results)=>{
//Si se genera un error con la bd lo lanzamos
if (error) throw error;
// Sino se genera error accedo al id que viene que viene en la posición cero de resultados
neWId=results[0].id
//a mi objeto nuevo persona le agrego el id
nuevaPersona.id=neWId
// Ahora sí mando como respuesta los datos de la persona que se agregó
response.json(nuevaPersona)
})
});
}]
//Actualizar una nueva persona de la lista
const actualizarPersona = [ (request,response)=>{
/*Todo esto se ejecuta solo si los datos fueron validados. Es decir, validarDatos dentro de
/validator/personas.js continuó con next() */
/*recupero el id de la persona haciendo un de-structur. La idea es crear una variable llamada id,
que está contenida con el mismo nombre id dentro de parms*/
const {id} = request.params
//creo el comando para seleccionar la persona con el id de mi tabla personas y lo guardo en sql
const sql = `SELECT * FROM personas WHERE id = ${id}`;
//Hago la conexión con mi base de datos
conn.query(sql, (error, results) => {
//Si se genera un error con la bd lo lanzamos
if (error) throw error;
// Sino se genera error, verificamos que venga algo en la respuesta, es decir que el id exista
if (results.length > 0) {
/*Si el id existe, almaceno en variables todos los valores que provienen del body (desestructuro) */
const {Nombre,Apellido,Edad,Mail,Celular} = request.body;
/* Si el id existe, podemos modificar los datos de la persona, entonces guardamos el comando
para modificar en sqlUpdate*/
const sqlUpdate = `UPDATE personas SET Nombre = '${Nombre}', Apellido = '${Apellido}',
Edad = '${Edad}', Mail = '${Mail}', Celular = '${Celular}' WHERE id = ${id}; `
//Hago la conexión con mi base de datos
conn.query(sqlUpdate,error => {
//Si se genera un error con la bd lo lanzamos
if (error) throw error;
/* Sino se genera error, mando en mi respuesta los de la persona modificados,
aquí ya se realizó la sentencia de sql */
response.json({id,Nombre,Apellido,Edad,Mail,Celular});
});
}
else {
//Sino existe el id imprimimos el mensaje:
response.status(410).json({error: "Este id no existe"});
}
});
}]
const eliminarPersona = [(request,response)=>{
/*recupero el id de la persona haciendo un de-structur. La idea es crear una variable llamada id,
que está contenida con el mismo nombre id dentro de parms*/
const {id} = request.params
//creo el comando para seleccionar la persona con el id de mi tabla personas y lo guardo en sql
const sql = `SELECT * FROM personas WHERE id = ${id}`;
//Hago la conexión con mi base de datos
conn.query(sql, (error, results) => {
//Si se genera un error con la bd lo lanzamos
if (error) throw error;
// Sino se genera error, verificamos que venga algo en la respuesta, es decir que el id exista
if (results.length > 0) {
// Si el id existe, lo podemos eliminar., entonces guardamos el comando para eliminar en: sqlDelete
const sqlDelete = `DELETE FROM personas WHERE id = ${id};`
//Hago la conexión con mi base de datos
conn.query(sqlDelete,error => {
//Si se genera un error con la bd lo lanzamos
if (error) throw error;
/* Sino se genera error, mando en mi respuesta el id de la persona eliminada,
aquí ya se realizó la sentencia de sqlDelete */
response.json(id);
});
} else {
//Sino existe el id imprimimos el mensaje
response.status(410).json({error: "Este id no existe"});
}
});
}]
//exporto las funciones hacia mi ruta /routers/personas.js
module.exports = {obtenerPersonas, obtenerPersona,añadirPersona, actualizarPersona, eliminarPersona}
Y listo!! ¡¡¡Tenemos nuestro REST-API terminado y conectado a una base de datos en la nube de Azure!!! ¡Fenomenal!.
¡¡¡¡Aquí te voy a dejar el repositorio con el código completo y listo para ser ejecutado!!!!
------>>>> LINK DEL REPOSITORIO COMPLETO LINK
Validación de los END-POINTS utilizando POSTMAN
Lo siguiente es realizar nuestras pruebas, para verificar que todo esté funcionando correctamente. Para esto te voy a dejar nuevamente un archivo tipo JSON para que podamos realizar las validaciones en POSTMAN VALIDACIONES
Ingresaremos a POSTMAN, pero antes, verifiquemos el estado actual de la Tabla personas dentro de nuestra base de datos que creamos con anterioridad. Para esto vamos a ir al portal de Azure, abriremos la terminal y nos conectaremos a nuestro servidor. Una vez dentro de nuestro servidor, utilizaremos el comando
USE basededatosdemoweb
Posteriormente utilizaremos
SELECT * FROM personas
Y obtendremos esta respuesta, este es el estado actual de nuestra tabla personas, que sería más o menos así.
Ahora sí, iremos a postman y con el método GET tendría que devolvernos los mismos datos que nuestra base de datos
1.- Prueba del método GET que nos devuelve todas las personas
¡¡Como pueden observar, efectivamente nos devuelve los mismos datos que nuestro base de datos!! Estamos haciéndolo de forma correcta
2.- Prueba del método GET que nos devuelve una persona por su ID, si ponemos, por ejemplo, el id No 2. Según nuestra base de datos, tendría que devolvernos el API todos los datos de Carlos Guzmán. Hacemos la petición en POSTMAN
Efectivamente, nos devolvió los resultados esperados.
3.- Probemos ahora con el método POST. Agregamos los datos en el body según nuestra definicón
y en postman obtenemos la siguiente respuesta
Ahora verificamos en nuestra base de datos, que se haya añadido correctamente la persona, para esto nuevamente en la terminal de Azure escribiremos
SELECT * FROM personas
¡¡¡¡Y podemos observar como en el registro con id=5 añadió los datos que le mandamos desde el API!!!!
Hasta ahora todo funciona muy bien.
Intentemos añadir una persona, con un dato faltante en el body
Como lo esperábamos nos arroja un error, por lo tanto, nuestras validaciones están funcionando correctamente
4.- Probemos ahora con el método PUT para cambiar los datos de una persona, intentaremos cambiar los datos del registro 5, que intencionalmente los puse repetidos para que podamos probar nuestro método PUT. Ponemos los datos en el body de acuerdo con nuestra definicón y obtenemos la siguiente respuesta
Verificamos nuevamente en nuestra base de datos, con el comando
sql
SELECT * FROM personas
Y en efecto, nos modificó correctamente los datos
5.- Finalmente probaremos el eliminar una persona, para esto, eliminaremos a la persona con el id=5. Esta es la respuesta obtenida de postman
Por último, verificamos nuevamente en nuestra base de datos
Y efectivamente borró los datos de esta persona
Siguientes pasos
¿Qué sigue ahora?
Vamos a subir nuestro nuevo REST-API en un App Service de Azure, para que podamos acceder a nuestro API desde cualquier lado, pero ya no lo haremos paso a paso, puesto que esto ya lo hicimos anteriormente, sino viste esa parte del tutorial o ya olvidaste los pasos, aquí te dejo el ENLACE para que puedas implementar este REST-API en la nube de Azure.
Yo ya implementé esto en la nube de AZURE, este es el enlace obtenido.
¡Te dejo por aquí el link para que puedas probarlo tu mismo!
LINK ----------------------->>>>>>>>>>>>>> https://personasapi-db.azurewebsites.net
Ahora, te invito a seguir con la siguiente parte del tutorial, en donde añadiremos un API-KEY a nuestro REST-API para que podamos tener un mejor control de ésta