@carlosbajo/micro v3.4.11

Micro

Este modulo de NPM se encarga de ocultar todas la configuración básica para que un microservicio pueda ser implementado con éxito, además brinda algunas características muy optimas para el manejo de los servicios.

Estructura básica de un microservicio (Minima)

Al llamar el modulo esté exporta 2 cosas uno start() y app

app : Contiene la comunicación con kafka. start : Método para inicializar el server de koa

Para implementar un servicio solo se necesita llamar el método start para (port: number, secret: key, googleKey)

Instalación

npm install @carlosbajo/micro --save

Continuous Delivery

Cuidado!, siguiente comando

npm version <new_version>

Ejectura git push --follow-tags tener el mente el cambio de versiones

Ejemplo

const fw = require('@carlosbajo/micro');
process.chdir(__dirname);

const port = (process.env.NODE_ENV === 'local') ? 3004 : 3001;
fw.start(port, 'roket', ''); // incia el server de Koa

Estructura del projecto

 api 
   | config
       | communication.js
       | router.js
   consumer
       | consumerName.js
   controllers
       | controllerName.js
   schemas
       | schemaName.js

Config /

communication.js

  module.exports = [];
  /* 
  En caso de que se tenga que se necesite comunicación entre microservicios se tiene que exportar el arreglo con el nombre del servicio por ejemplo
  
  module.exports = ['servicename','servicename2'];
  */

routes.js

/* 
Exportar el objeto de rutas posibles de la api, en este caso el contralador debe de existir así como la accion en el controlador del mismo.
*/
module.exports = {
  'GET /version': {
    controller: 'index',
    action: 'version'
  }
};
/*
Si no se desea exportar un ruta simplemente exportar
module.exports = {}
*/

Consumer /

example.js

const { app } = require('@carlosbajo/micro');

module.exports = {
  getById: async req => {
    const id = req.arg.id ? req.arg.id : req.parent.id;
    const payload = await app.models.actividadespropuestas.findOne({ _id: new mongo.ObjectId(id), status: 1 });
    return payload;
  },
};

En este caso los modelos que son generados en el apartado de schemas y son inyectados en el objeto app y podemos usar los métodos de mongoose como findOne o find.

Al final es importante retornar el resultado en este caso todos los métodos en los consumer son de retorno.

El método RPC (Comunicación entre servicios) el metodo RPC se puede comunicar con otros métodos definidos en los consumer de otros microservicios, para lograr esto solo necesitamos saber el nombre del microservicio y el consumer de ese microservicio.

el metodo rpc se encuentra en pubsub.

 const getFromMicro = await app.Pubsub.rpc('entorno.micro.metodo', args);

Controllers

Aquí se definen los controladores del projecto en este caso los contraladores responden a las rutas que se definene en config/routes.js.

example.js

const { app } = require('@carlosbajo/micro');
const packageJson = require('../../package.json');

module.exports = {
  version: async ctx => {
    const payload = {
      microservice: app.name,
      version: packageJson.version,
      time: app.deployTime
    };

    ctx.body = payload;
    return payload;
  }
};

Schemas/

En está carpeta se definen los schemas de mongo en este caso el nombre del archivo es tomado como nombre del schema example.js

module.exports = {
  datasource: 'mongo',
  properties: {
    materiaId: {
      type: String
    },
    aprendizajes: [
      {
        aprendizajeId: {
          type: String
        },
        nombre: {
          type: String
        }
      }
    ],
    modalidad: {
      type: String
    },
    actividad: {
      type: String
    },
    proposito: {
      type: String
    },
    /**
     * Indica la visibilidad del documento
     *
     * @access private
     * @type {!number}
     *
     * 1 => Documento visible
     * 2 => Histórico
     * 3 => Documento borrado lógicamente
     *
     */
    status: {
      type: Number,
      default: 1
    }
  }