Conectando con nuestro microservicio de datos

Excelente, lo que quiere decir que nuestra API se convierte en cliente con respecto al server que sirve el servicio de nuestra BD.

La verdad creo que esta clase deberia añadir el hacer la comunicación con HTTP2 con gRPC o un message broker (Apache Kafka); que es la manera en que se maneja la comunicación entre microservicios en lo laboral

Si usamos typescript podemos definir una interfaz para la definición de métodos en los archivos dentro del store 😃

Excelente clase muchas gracias a toda la gente de platzi !!
remote.js

const axios = require('axios');

function CreateRemoteDataBaseApi (host, port) {
  const remoteDataBaseCall = axios.create({
    baseURL: `${host}:${port}`,
    headers: {
      'Content-Type': 'application/json',
      'Accept': 'application/json'
    }
  })

  async function request({method, url, data}) {
    const reponse = await remoteDataBaseCall({
      method: method,
      url: url,
      data: data
    });
    return reponse.data.body;
  }

  function list(table) {
    return request({
      method: 'GET',
      url: `/${table}`,
    })
  }

  function get(tabla, id) {
    return request({
      method: 'GET',
      url: `/${tabla}/${id}`,
    })
  }

  function query(tabla, query, join = '') {
    return request({
      method: 'GET',
      url: `/query/${tabla}`,
      data: {
        "query": query,
        "join": join
      }
    })
  }

  function create(table, data) {
    return request({
      method: 'POST',
      url: `/${table}`,
      data
    })
  }

  function update(table, data_id, data) {
    throw new Error('Not implemented');
  }

  async function upsert(tabla, data) {
    return request({
      method: 'PUT',
      url: `upsert/${tabla}`,
      data
    })
  }

  async function remove(tabla, id) {
    return request({
      method: 'DELETE',
      url: `/${tabla}/${id}`
    })
  }

  return {
    list,
    get,
    query,
    create,
    update,
    upsert,
    remove,
  };
}

module.exports = CreateRemoteDataBaseApi;

Reto resuelto:

const request = require('request');

let urlRemote;

function req(method, table, data = null) {
    let url = `${urlRemote}/${table}`;
    let body = '';

    if(data && method === 'GET') {
        url += `/${id}`;
    } else if(data) {
        body = JSON.stringify(data);
    }
    
    return new Promise((resolve, reject) => {
        request({
            url,
            method,
            body,
            headers: {
                'content-type': 'application/json'
            }
        },(error, req, result) => {
            if(error) {
                console.error('Error en la base de datos', error);
                return reject(error.message);
            }

            const res = JSON.parse(result);
            return resolve(res.body);
        });
    });
}

function insert(table, data) {
    return req('POST', table, data);
}

function update(table, data) {
    return req('PUT', table, data);
}

module.exports = class RemoteStore {

    constructor(host, port) {
        urlRemote = `http://${host}:${port}`
    }

    list(table) {
        return req('GET', table);
    }

    get(table, id) {
        return req('GET', table, id);
    }

    upsert(table, data) {
        if(data.id) {
            return update(table, data);
        }
        return insert(table, data);
    }
}

Ok, sera necesario volverlo a ver

Ayuda, en el archivo remote-mysql porque se utiliza la palabra new para utilizar a remote?

Podria alguien explicarme porque al profesor si le corrio el codigo? Utilizando el new sin usar la clase? jaja no entiendo

les comparto mi archivo de peticiones con axios

const axios = require('axios');

class AxiosInstance {
    constructor(config = {}) {
        this.axios = axios.create(config);
    }

    send(url, method, data) {
        return new Promise((resolve, reject) => {
            this.axios({
                method,
                url,
                data
            })
                .then(response => resolve(response.data))
                .catch(error => reject(error))
        })
    }
}

module.exports = AxiosInstance;

y el mysqlRemote

const AxiosInstance = require('./../utils/axios-instance');
const config = require('./../config');

class MysqlRemote {
    constructor() {
        this.request = new AxiosInstance({
            baseURL: config.mysql.mysqlService.host,
            timeout: 5000,
            headers: {'Content-Type': 'application/json'},
        })
    }

    list(table) {
        return this.request.send(`/${table}`, 'GET');
    }
}

module.exports = new MysqlRemote();

a ver en “resumidas” palabras está haciendo peticiones desde un microservicio hacía otro desde http, lo anterior también se puede hacer con axios, está chévere este mundillo de los microservicios 😁

Si tenemos multiples instancias de un micro servicio, como balanceamos las cargas de solicitudes de cada una de ellas?

Si es que tienen problemas con errores internos, vayan al código de error.js
en

response.error(req,res,err,status)

Pongan err para ver el tipo de error. Ahora después de aquello si tienen este error.

[error]: connect ECONNREFUSED 127.0.0.1:80

Deben arrancar los dos servicios de api/index.js y el de mysql/index.js en 2 terminales.

✌

AYUDA cuando hago leer users en insomnia me devuelve
un 500 en en consola me da este error

[error]: connect ECONNREFUSED 127.0.0.1:80
error en la DB remota Error: connect ECONNREFUSED 127.0.0.1:80
at TCPConnectWrap.afterConnect [as oncomplete] (net.js:1134:16) {
errno: ‘ECONNREFUSED’,
code: ‘ECONNREFUSED’,
syscall: ‘connect’,
address: ‘127.0.0.1’,
port: 80

Todo perfecto, lo único que no entendí es que ¿se puede crear una new Instance de una función? ¿O por lo menos se podía?
A mi me dio error, asi que solo la invoqué como función.

Usando la orientación del profe a funciones como clases y axios me salió esto:

const axios = require("axios");

function createRemoteDB(host, port) {
  const URL = `htt://${host}:${port}`;

  function handleRequest(method, table, data) {
    const config = {
      method,
      url: `${URL}/${table}`,
      data: data || null,
    };
    return new Promise((resolve, reject) => {
      axios(config)
        .then((response) => {
          resolve(response.data.response);
        })
        .catch((error) => {
          reject(error);
        });
    });
  }


  function list(table) {
    return handleRequest("GET", table);
  }

  return {
    list
  };
}

module.exports = createRemoteDB;

Luego en el remote-mysql.js

const remote = require("./remote");
const config = require("../config");

module.exports = new remote(
  config.microservice.db.host,
  config.microservice.db.port
);

Es más parecido a lo que hizo el profe, pero usando Axios que es la misma librería que se suele usar en el frontend, aunque para esto toca instalar axios

npm i axios

levantamos los dos servicios

al principio me confundia, pero ya poco a poco me esta quedando claro… me parece muy bien aplicar esto de servicios remote, para la api

Al cambiar la base de datos a remote-mysql en index de la carpeta de usuario me manda el error que la tabla no ha sido identificada o no existe. Alguien sabe a que se puede deber esto?

Interesante dado que es tener cada servicio en un backend aparte (incluso en express con un app para cada uno) y comunicarse mediante peticiones HTTP (Se pueden hacer también con fetch o con la librería axios que a muchos le gusta)

Es impresionante esto de microservicios.
Entonces al crear microservicios estamos refactorizando y modularizando a un nivel mucho más abstracto nuestra arquitectura del servidor?