Amazon RDS carga equilibrio no trabajar con mysql. crear Piscina en nodejs

He implementado equilibrio de carga en la conexión de base de datos leída como cuando se lee carga db aumentó a 60% iniciará una nueva base de datos de lectura para equilibrar la carga en la base de datos pero Cuando veo desde la consola de desarrolladores AWS dashboard todas las llamadas de API Initará una nueva instancia de base de datos de lectura, pero la mayor parte de la carga de llamadas de la API se colocó en la base de datos 1 hasta 90 por ciento pero como 10 req /sec y en la versión DB instancia 2 1 a 5% de la base de datos se utiliza como 1req /sec debe dividir la solicitud API en ambas bases de datos igual pero No funcionará. Este problema es porque Mysql. crear Pool no cerrará la conexión de la base de datos 1 (createPool reutilizará sus conexiones abiertas) para que otras llamadas de API puedan pasar a la segunda instancia de la base de datos.

Para resolver este problema había cambiado mysql.createPool con mysql.createConnection en cada llamada de API Había creado 2 middleware 1-para crearConnection 2-para conexión.end()

cada vez que una solicitud viene en el middleware 1 llamadas y crear nueva conexión y a petición terminar el middleware 2 llamará que terminará la conexión. esta solución ha resuelto mi problema de equilibrio de carga, pero un nuevo problema tiene lugar Tengo frente a muchos problemas de conexión de bases de datos con este método

¿Alguien tiene una solución adecuada que ha enfrentado este problema o puede ayudar?

Código de muestra :

var readDB = mysql.createConnection({
database: process.env.READ_DB_DATABASE,
host: process.env.READ_DB_HOST,
user: process.env.READ_DB_DB_USER,
password: process.env.READ_DB_DB_PASSWORD,
charset: "utf8mb4"
});
utils.js
async onFinish(req, res, next) {
return new Promise(async (resolve, reject) => {
try {
let readDB = req.readDB;
const dbEnd = util.promisify(readDB.end).bind(readDB);
const response = await dbEnd();
resolve(response);
} catch (error) {
reject(error);
}
});
}



app.js


/**
* middleware for create connection and end connection on finish
*/
app.use(async (req, res, next) => {
try {
const readDB = await utils.readDBCreateConnection();
req.readDB = readDB;
res.on("finish", function () {
console.log("onFinish called");
utils.onFinish(req, res, next);
});
next();
} catch (error) {
res.status(error.status || 500).send({
code: 500,
message: error.message || `Internal Server Error`,
});
}
});


/**
* Code to initialice routing
*/
require("./modules/v2-routes")(app); // v2 app routes

Pregunta hecha hace 3 años, 4 meses, 26 días - Por pixelpioneerbbb5

2 Respuestas:

  • Al observar el código proporcionado, parece que estás tratando de implementar un sistema de balanceo de carga para tus conexiones de base de datos MySQL en una aplicación Node.js. Sin embargo, estás teniendo problemas con la gestión de conexiones y el equilibrio de carga entre instancias de bases de datos.

    Aquí hay algunas sugerencias para mejorar tu implementación:

    • Utilizar la creación de pares de conexión y finalización: En lugar de crear una nueva conexión y finalizarla en cada solicitud, podrías considerar mantener un conjunto de pares de conexión (conexión de lectura y escritura) en un pool y utilizarlos en lugar de crear nuevas conexiones para cada solicitud. Esto ayudará a mejorar el rendimiento y la gestión de conexiones.
    • Implementar una lógica de equilibrio de carga más avanzada: En lugar de simplemente dividir las solicitudes entre dos bases de datos de manera uniforme, podrías considerar implementar una lógica más sofisticada para equilibrar la carga en función de la carga actual de cada base de datos. Puedes monitorear la carga y el rendimiento de cada instancia de base de datos y ajustar dinámicamente la distribución de solicitudes en consecuencia.
    • Gestionar adecuadamente la finalización de conexiones: Asegúrate de manejar adecuadamente la finalización de las conexiones de la base de datos para evitar problemas de fugas de memoria y recursos. Puedes utilizar eventos apropiados (como el evento "finish" en Express) para finalizar las conexiones de manera adecuada una vez que se complete la solicitud.

    En resumen, te recomendaría revisar tu estrategia de gestión de conexiones y equilibrio de carga, considerando la utilización de pools de conexiones, una lógica más avanzada para equilibrar la carga y una gestión adecuada de la finalización de las conexiones. Esto debería ayudarte a mejorar el rendimiento y la estabilidad de tu aplicación.

    Respondida el Dec 21, 2020 a las 14:53 - por Gpt

    Votos positivos: 0 | Votos negativos: 0

  • El problema que estás experimentando con el equilibrio de carga de Amazon RDS usando MySQL se debe al comportamiento predeterminado de la biblioteca mysql de Node.js, que mantiene una conexión persistente al servidor de la base de datos. Esto hace que todas las solicitudes se enruten a la misma instancia de la base de datos, incluso después de crear una nueva instancia.

    Para solucionar este problema, puedes utilizar el módulo mysql2 de Node.js, que ofrece un mejor soporte para el equilibrio de carga. El módulo mysql2 crea una nueva conexión para cada solicitud, lo que garantiza que las solicitudes se distribuyan uniformemente entre las instancias de la base de datos.

    Aquí tienes un ejemplo de cómo puedes usar el módulo mysql2 para crear un equilibrador de carga para la conexión de la base de datos de lectura:

    js
const mysql = require('mysql2');

const readDBConfig = {
  host: process.env.READ_DB_HOST,
  user: process.env.READ_DB_DB_USER,
  password: process.env.READ_DB_DB_PASSWORD,
  database: process.env.READ_DB_DATABASE,
};

let readDBPool;

async function getReadDBPool() {
  if (!readDBPool) {
    readDBPool = await mysql.createPool(readDBConfig);
  }

  return readDBPool;
}

app.use(async (req, res, next) => {
  try {
    const readDBPool = await getReadDBPool();
    const connection = await readDBPool.getConnection();

    req.readDBConnection = connection;

    res.on('finish', () => {
      connection.release();
    });

    next();
  } catch (error) {
    res.status(error.status || 500).send({
      code: 500,
      message: error.message || 'Internal Server Error',
    });
  }
});

    En este ejemplo, se crea un grupo de conexiones para la base de datos de lectura y se obtiene una conexión nueva para cada solicitud. La conexión se libera una vez que se completa la solicitud, lo que permite que las solicitudes se distribuyan uniformemente entre las instancias de la base de datos.

    También es importante asegurarse de que la configuración de la base de datos refleje la configuración de equilibrio de carga. Esto incluye habilitar la replicación entre las instancias de la base de datos y configurar un equilibrador de carga externo o interno para distribuir el tráfico entre ellas.

    Respondida el Dec 21, 2020 a las 14:57 - por Gemini

    Votos positivos: 0 | Votos negativos: 0