No tienes acceso a esta clase

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

Manejando un Pool de conexiones

7/27
Recursos

Aportes 15

Preguntas 13

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

Un pool de conexiones es un conjunto limitado de conexiones a una base de datos, que es manejado por un servidor de aplicaciones de forma tal, que dichas conexiones pueden ser reutilizadas por los diferentes usuarios.

Manejando un Pool de conexiones

Hay un problema con getConnection. El problema es que cada vez que llamamos a getConnection, lo que hacemos internamente en el codigo es llamar y llamar y llamar, es decir hacer request continuamentes, eso esta mal porque puede sobrecargar el servidor de request. Entonces, esto es un problema porque por cada request se crea una negociacion con la db, se tarda 20ms o mas, y asi vamos saturando el servidor. La solucion es usar pool.

Sin un pool, yo deberia cerrar las conexiones manuelament.e

Que es un pool? Un pool de conexiones es un conjunto limitado de conexiones a una base de datos, que es manejado por un servidor de aplicaciones de forma tal, que dichas conexiones pueden ser reutilizadas por los diferentes usuarios. Un pool optimiza

Lo que hace el pool es sencillamente es ser un mediador entre las bases de datos y el cliente. Entonces a medida que los clientes empiecen a hacer consultas, la aplicacion de manera asincrona conectara con el pool y el pool se encargara tanto de abrir o cerrar conexiones para que la informacion siga trabajando de manera eficiente. Pero un pool es mucho mas inteligente que eso, ya que permite REUTILIZAR DATA QUE OTROS CLIENTES YA ACCEDIERON, CLARO SIEMPRE Y CUANDO LA DATA A REUTILIZAR SEA LA MISMA QUE ESOS CLIENTES NECESITABAN , y a su vez lograremos que los servidores no se saturen y nuestra app en el background trabajara con las consultas, y asi evitara un problema en el proceso.

Comparto mi c贸digo para el create, delete y update para las categor铆as.

Ese pool es b谩sicamente un singleton

users.service.js

const boom = require('@hapi/boom');

const pool = require('../libs/postgres.pool');

const getConnection = require('../libs/postgres');

class UserService {
  constructor() {
    this.users = [];
    this.pool = pool;
    this.pool.on('error', (err) => console.error(err));
  }

  async create(data) {
    return data;
  }

  async find() {
    const query = 'SELECT * FROM tasks';
    const rta = await this.pool.query(query);
    return rta.rows;
  }

  async findOne(id) {
    return { id };
  }

  async update(id, changes) {
    return {
      id,
      changes,
    };
  }

  async delete(id) {
    return { id };
  }
}

module.exports = UserService;

la verdad en este curso en espec铆fico estoy teniendo muchos problemas con el c贸digo, estoy recibiendo errores como this.pool.query(query);

Mi resumen!

Ahora,mostrare como el codigo ha cambiado:

//libs/postgres.pool.js

const { Pool } = require('pg');

  const pool = new Pool({
    host: 'localhost',
    port: 5432,
    user: 'nico',
    password: 'admin123',
    database: 'my_store'
});

//Fijate que el codigo ha cambiado, ahora el trabajar con el driver pg no se basa en ser una funcion, sino mas bien un objeto. y desde aca empezamos a trabajar con pool, fijate las variables... Ahora tambien se puede aprecier que el codigo es mas simple.

module.exports = pool;
// services/product.service.js  

//En este archivo elimine unas lineas de codigo para que sea mas facil de entender y asi no ver todo el codigo que no importa

class ProductsService {

  constructor(){
    this.products = [];
    this.generate();
    **this.pool = pool
    this.pool.on('error', (err) => console.error(err)) //1)**
  }

  async find() {
    const query = 'SELECT * FROM tasks'
    const rta = await this.pool.query(query);
    return rta.rows; //2) Accedemos a pool y especifcamente le passamos el query que este metodo necesita
  }

  1. El punto 1) es el mas importante, por que? Bueno, porque lo que hace es ser las funcion prinicpal de pool, es decir, sabiendo que pool lo que hace es NO LLAMAR continuamente a una funcion y lograr no sobresaturar el servidor/db, la manera en la que lo logramos es poner a POOL en el constructor. Por que? Bueno simplemente porque lo que esto nos permite es justamente llegar a pool desde los diferentes servicios, es decir, el acceso a pool es compartido!, Por lo tanto, al estar pool en el constructor, y nosotros tener dentro de la class ProductService muchos servicios, como find,findOne,etc lo que hacemos es LLAMAR A POOL UNA SOLA VEZ DESDE EL COSNTRUCTOR, Y LUEGO CON CADA SERVICIO COMO FIND,FINDONE,ETC Le pasamos el query necesario! ESO ES LO QUE HACE QUE POOL SEA TAN EFICIENTE!

Por lo tanto, lo que podemos entender es que: la class ProductService crea un canal con el servidor con el mediador pool. Y cada servicio dentro de la clase genera su consulta adecuada. Por lo tanto, Otro archivo como no se鈥 category.service, accedera a pool y abrira otro canal y accedera con su servicios por otro canal.


Yo no agregue un nuevo script para manejar el pool de conexiones, por el contrario lo agregu茅 al que ya tenia

Una vez realizado esto, modifique todo mi servicio para que usara el connection pool con promesas:

Tuve que hacer ciertas modificaciones porque ahora mis campos de producto cambiaron:

Pero una vez realizados estos ajustes pude usar todos mis endpoints hacia la base de datos de forma fluida

Hasta este punto por cada llamado a de un servicio a la base de datos se esta creando una conexi贸n, de implementarse asi en todos los servicios se estarian creado multiples conexiones y esto no seria una buena practica.

Aqu铆 entra la interfaz de Pool de conexiones que permite usar varias conexiones en toda la aplicaci贸n pero reutilizando la primera.

Del modulo de pg admin importaremos el modulo de Pool y utilizaremos la siguiente configuraci贸n en un nuevo archivo dentro de libs llamado postgres.pool.js:

Ahora se debe implementar en los servicios, donde se remplazara la conexi贸n que anteriormente se tenia de la siguiente manera.

Manejando un Pool de conexiones
Modificamos el archivo creado en libs, y modificamos Client por Pool

const  { Pool } = require('pg');

  const pool = new Pool({
    host: "localhost",
    port:5432,
    user:"juancacode",
    password:"admin123",
    database:'my_store_db'
  })

  module.exports = pool;

Llamamos en nuestro servicio
const pool = require(鈥欌/libs/postgres.pool鈥);

modificamos el constructor

class ProductsService {
  constructor() {
    this.products = [];
    this.generate();
    this.pool = pool;
    this.pool.on('error',(err)=>console.error(err));
  }

lo aplicamos a la funci贸n

async find() {
    const query = "SELECT * FROM tasks";
    const res = await this.pool.query(query);
    return res.rows;
  }

Me gustaria que se brinde una solucion a como conectar los servicios a la Base de Datos. Me parece muy mal que se indique al alumno 鈥渞ealicen todas las demas conexiones a los servicios鈥 teniendo una minima guia con la tabla tasks.

Creo que pooling esta relacionado con los websockets, creo que son Event emitters incluso lo de > this.pool.on(鈥榚rror鈥, cb)
es algo que se usa en webSockets si saben Socketio sabr谩n a lo que me refiero.

Mi update:

async update(id, changes) {
try {
const keys = Object.keys(changes);
const values = Object.entries(changes).map((b) => b[1]);
const updates = keys.map((key, index) => ${key}=$${index + 1}).join();
const query = UPDATE users SET ${updates} WHERE id = $${ keys.length + 1 };
await this.pool.query(query, [鈥alues, id]);
return {
id,
鈥hanges,
};
} catch (error) {
return 鈥楨rror on updating鈥 + error;
}
}

Super, ya quedo el pool en cada service