No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Conectando con nuestro microservicio de datos

20/29
Recursos

Aportes 22

Preguntas 6

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Reg铆strate o inicia sesi贸n para participar.

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

Justo ahora request esta obsoleto desde el 11 de febrero del 2020.

Pero hay otras alternativas como node-fetch que te permite hacer lo mismo de forma parecida

este es mi ejemplo:

const fetch = require("node-fetch");

exports.createRemoteDB = (host, port) => {
    const URL = `htt p://${host}:${port}`;

    async function get(TABLE, param) {
        fetch(`${URL}/${TABLE}/${param}`)
            .then(response => {
                return response.json();
            })
            .then(json => {
                return json;
            })
            .catch(err => {
                return err.message;
            })
    }

    //otras funciones...

    return {
        get,
    }
}

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 馃槂

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?

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;

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 鈥渞esumidas鈥 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: 鈥楨CONNREFUSED鈥,
code: 鈥楨CONNREFUSED鈥,
syscall: 鈥榗onnect鈥,
address: 鈥127.0.0.1鈥,
port: 80

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?

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

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?