No tienes acceso a esta clase

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

Separando la base de datos a un microservicio

19/29
Recursos

¿Cómo crear un microservicio para la base de datos?

¡Explora el mundo de los microservicios y descubre cómo estructurar tus aplicaciones de forma eficiente y modular! Un microservicio puede mejorar la flexibilidad de tu sistema, permitiéndote manejar diferentes aplicaciones que interactúan con la misma base de datos desde distintos lenguajes de programación como Python. Aprenderás a crear un sistema de clasificación usando Machine Learning para recopilar y actualizar datos en tiempo real.

¿Cómo crear una estructura para el microservicio?

Para comenzar, asegúrate de que tu aplicación esté lista para la modularización. Empieza creando una nueva carpeta para el microservicio de base de datos, llamémosla mysql. En esta carpeta, crea un archivo index.js donde definirás tu API y establecerás cómo se comunicará. A continuación, se muestra un ejemplo de cómo podrías hacerlo usando Express en Node.js:

const express = require('express');
const bodyParser = require('body-parser');
const config = require('../config');

const app = express();
app.use(bodyParser.json());

app.listen(config.mysqlService.port, () => {
  console.log(`Servicio MySQL escuchando en el puerto ${config.mysqlService.port}`);
});

¿Cómo definir las rutas y funciones necesarias?

Para manejar las operaciones de base de datos, necesitarás definir rutas específicas que correspondan a las acciones que deseas realizar, como listar, obtener, insertar y actualizar registros. A continuación, se muestra cómo podrías definir estas rutas:

const router = require('express').Router();

router.get('/:table', list);
router.get('/:table/:id', get);
router.post('/:table', insert);
router.put('/:table/:id', update);

function list(req, res, next) {
  const data = await store.list(req.params.table);
  res.json(data);
}

function get(req, res, next) {
  const data = await store.get(req.params.table, req.params.id);
  res.json(data);
}

function insert(req, res, next) {
  const data = await store.insert(req.params.table, req.body);
  res.json(data);
}

function update(req, res, next) {
  const data = await store.update(req.params.table, req.params.id, req.body);
  res.json(data);
}

module.exports = router;

¿Cómo probar el microservicio?

La mejor forma de asegurarte de que tu nuevo microservicio funciona correctamente es probándolo. Puedes usar herramientas como Postman o cURL para enviar solicitudes HTTP a tu microservicio y ver si responde de la forma esperada. A continuación, se muestra cómo podrías realizar una prueba simple:

curl http://localhost:3001/user

Este comando debería devolver la lista de usuarios en la base de datos. Si no, asegúrate de que las rutas y el almacen (store) estén correctamente configurados.

Una recomendación para tu arquitectura de microservicios

En una arquitectura de microservicios eficiente, no todos los servicios deben estar expuestos al público. Considera mantener este servicio de base de datos como un servicio interno donde solo las aplicaciones necesarias tengan acceso directo. Esto mejora la seguridad y la integridad de los datos.

Los microservicios bien diseñados y estructurados son una parte vital de aplicaciones escalables y flexibles. ¡Sigue explorando y mejorando tu arquitectura para lograr un sistema más robusto y eficiente!

Aportes 18

Preguntas 6

Ordenar por:

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

Un microservicio es una pequeña aplicación que se encarga de una parte de un software más complejo de manera aislada, y se comunica con el resto del software mediante diferentes métodos: peticiones HTTP, o algún sistema de colas. micro.js es una librería muy pequeña (alrededor de 100 líneas de código) de JavaScript, que nos permite usar Node.js para crear fácilmente microservicios que funcionen sobre el protocolo HTTP, y haciendo uso de Async/Await y todas las características que se incluyeron en ECMAScript 2015 para facilitarnos el programarlos.

Una barbaridad lo que se aprende en cada curso con el profe Carlos

Primera vez que veo los Microservicios lo que vi lo entendi, seguimos.!!

de verdad que claro me esta quedando esto de los microservicios

wooo creo que esto es complicado, más porque el profe no esta usando un metodología estructurada de trabajo como lo es MVC. Se que ese modelo no aplicaría para APIs pero creo que es complicado seguirle el hilo he ir entendiendo todo!

Algo me dice que aquí se pueden hacer ataques de inyección de SQL y que deberíamos validar los datos antes de guardarlos en la base de datos.

Separando la base de datos a un microservicio

Creamos ./mysql/index.js:

const express = require("express");
const app = express();
const config = require('../config')
const router = require('./network')


app.use(express.urlencoded({extended: true}))
app.use(express.json())

//* RUTAS
app.use('/', router)

app.listen(config.mysqlService.port, () => {
  console.log(`Servidor MySQL escuchando en el puerto ${config.mysqlService.port}`);
})

Creamos ./mysql/network.js:

const express = require('express');

const response = require('../network/response');
const Store = require('../store/mysql');

const router = express.Router();

router.get('/:tabla', list)
router.get('/:tabla/:id', get)
router.post('/:tabla', insert)
router.put('/:tabla', upsert)

async function list(req, res, next) {
  try {
    const datos = await Store.list(req.params.tabla);
    response.success(req, res, datos, 200);
  } catch (error) {
    next(error);
  }
}

async function get(req, res, next) {
  try {
    const datos = await Store.get(req.params.tabla, req.params.id);
    response.success(req, res, datos, 200);
  } catch (error) {
    next(error);
  }
}

async function insert(req, res, next) {
  try {
    const datos = await Store.insert(req.params.tabla, req.body);
    response.success(req, res, datos, 201);
  } catch (error) {
    next(error);
  }
}

async function upsert(req, res, next) {
  try {
    const datos = await Store.upsert(req.params.tabla);
    response.success(req, res, datos, 200);
  } catch (error) {
    next(error);
  }
}

module.exports = router;

Actualizamos ./config.js:

module.exports = {
  api: {
    port: process.env.API_PORT || 3000,
  },
  jwt: {
    secret: process.env.JWT_SECRET || 'notASecret!'
  },
  mysql: {
    host: process.env.MYSQL_HOST || 'sql5.freemysqlhosting.net',
    user: process.env.MYSQL_USER || 'sql5437281',
    password: process.env.MYSQL_PASS || 'xMYIzS32wz',
    database: process.env.MYSQL_DB || 'sql5437281',
  },
  mysqlService: {
    port: process.env.MYSQL_SRV_PORT ||3001
  }
}

Ahora si hacemos GET https://localhost:3001/post o GET https://localhost:3001/user obtendremos la información de la base de datos.

I N C R E I B L E !!! 😮

Me gusta los cursos donde los profesores tienen errores y muestran donde estuvo ese error y como lo solucionan, algunos solo hacen el corte y dicen que tuvieron un error y ya lo corrigieron. Deberian hacerlo mostrando como solucionan sus propios errores.

Es implementación es interesante, pero por favor el naming ya no se entiende nada; hay demasiadas cosas llamadas “network” :cr

Algo que me gustaría agregar a esta clase es que los errores del network.js de mysql deberían ser manejados, aún no comprendo bien para que sirve la función next así que mi código quedó así:

async function list(req, res, next) {
    try {
        const dataList = await store.list(req.params.table)
        response.success(req, res, dataList, 200)
    } catch (error) {
        response.error(req, res, 'Internal error', 500, error)
    }

}
async function get(req, res, next) { 
    try {
        const data = await store.get(req.params.table, req.params.id)
        response.success(req, res, data, 200)
    } catch (error) {
        response.error(req, res, 'Internal error', 500, error)
    }
}
async function insert(req, res, next) {
    try {
        const data = await store.insert(req.params.table, req.body)
        response.success(req, res, data, 201)
    } catch (error) {
        response.error(req, res, 'Internal error', 500, error)
    }
 }
async function update(req, res, next) {
    try {
        const data = await store.upsert(req.params.table, req.body)
        response.success(req, res, data, 201)
    } catch (error) {
        response.error(req, res, 'Internal error', 500, error)
    }
 }

super!

La idea es hacer un pequeño api que exponga únicamente el CRUD a base de datos.

El uso del Store, ¿no tendríamos que ponerlo dentro del controller?

Muy bueno

muy chevere

genial 😃

Excelente. Vamos a separarlo.