AWS: error 502 de API gateway aleatoriamente con fallas de segmentación en tiempo de ejecución

2024-6-23 • tag-icon

AWS: error 502 de API gateway aleatoriamente con fallas de segmentación en tiempo de ejecución

Estoy usando AWS y tengo una API que se llama a través de una puerta de enlace API que llama a una función lambda de Node.js.

Muy a menudo, pero de forma aleatoria, recibo 502 respuestas, pero cuando intento volver a intentarlo inmediatamente con exactamente la misma solicitud, obtengo una respuesta normal. Entonces decidí buscar en los registros para ver si podía encontrar algún problema.

Lo siguiente es lo que encontré para 1 de las solicitudes:

RequestId: xxxxx Error: Runtime exited with error: signal: segmentation fault Runtime.ExitError

así como también:

xxxx    ERROR   Uncaught Exception  
{
    "errorType": "Error",
    "errorMessage": "Quit inactivity timeout",
    "code": "PROTOCOL_SEQUENCE_TIMEOUT",
    "fatal": true,
    "timeout": 30000,
    "stack": [
        "Error: Quit inactivity timeout",
        "    at Quit.<anonymous> (/opt/nodejs/node_modules/mysql/lib/protocol/Protocol.js:160:17)",
        "    at Quit.emit (node:events:527:28)",
        "    at Quit.emit (node:domain:475:12)",
        "    at Quit._onTimeout (/opt/nodejs/node_modules/mysql/lib/protocol/sequences/Sequence.js:124:8)",
        "    at Timer._onTimeout (/opt/nodejs/node_modules/mysql/lib/protocol/Timer.js:32:23)",
        "    at listOnTimeout (node:internal/timers:559:17)",
        "    at processTimers (node:internal/timers:502:7)"
    ]
}

El siguiente es mi conector SQL reutilizable:

const CustomSecret = require('../secrets/CustomSecret');
const mysql = require("mysql");

module.exports = class MySqlConnect {

    databaseCredObject;

    constructor() {
    }

    async queryDb(sql, args) {

        if (!this.databaseCredObject) {
            await this.fetchSecret();
        }

        let connection = null;
        const connection_settings = {
            host: this.databaseCredObject.host,
            user: this.databaseCredObject.username,
            password: this.databaseCredObject.password,
            database: 'logbook'
        };

        connection = mysql.createConnection(connection_settings);

        return new Promise((resolve, reject) => {
            connection.connect(function (err) {
                if (err) {
                    console.log('error when connecting to db:', err);
                } else {
                    console.log('Connected');
                    connection.query(sql, args, function (err, result) {
                        connection.end();
                        if (err) {
                            return reject(err);
                        }
                        return resolve(result);
                    });
                }
            });
        });
    }

    async fetchSecret() {
        const databaseCredString = await CustomSecret.getSecret('secretname', 'eu-west-2');
        this.databaseCredObject = JSON.parse(databaseCredString);
    }
}

Finalmente este es un ejemplo de mi función lambda (versión abreviada):

const {compress, decompress} = require("compress-json");

const MySqlConnect = require("customPackagePath/MySqlConnect");
const CustomJwt = require("customPackagePath/CustomJwt");
const AWS = require("aws-sdk");
const warmer = require("lambda-warmer");

exports.handler = async (event) => {


    if (await warmer(event)) {
        console.log("Warming");
        return 'warmed';
    }

    let responseCode = 200;
    let response = {};

    response.headers = {
        'Content-Type': 'application/json',
        'Access-Control-Allow-Origin': '*'
    };

    const bodyContent = JSON.parse(event.body);
    const dataType = bodyContent.dataType;
    const webAuth = new CustomJwt();
    const decodedToken = webAuth.decodeToken(event.headers.Authorization);
    const userUUID = decodedToken['uuid'];
    
    
    const connection = new MySqlConnect();
    
    let sql;

    switch (dataType) {
        case 'userPreferences':
            sql = await connection.queryDb('SELECT * FROM user WHERE uuid = ?', [userUUID]);
            break;
    }


    let data = [];

    for (let index in sql) {
        data.push(JSON.parse(JSON.stringify(sql[index])));

    }


    const returnData = {
        data
    };


    let compressed = compress(returnData);

    response.statusCode = responseCode;
    response.body = JSON.stringify(compressed);


    return response;
};

Ahora soy nuevo en cosas de infraestructura. Pero me parece que una vez que se llama a una función lambda, no se cierra ni finaliza correctamente. También estoy usando el calentador lambda para mantener calientes las funciones como se ve en el código lambda y no estoy seguro si eso está causando algún problema.

Agradezco cualquier ayuda con esto ya que parece que no puedo entenderlo.

Gracias

Respuesta1

Después de investigar más, decidí agregar esto a mi función Lambda:

exports.handler = async (event, context, callback) => {

y el regreso asi

callback(null, response);

y desde entonces este problema parece haberse resuelto. No estoy del todo seguro de por qué, pero por ahora tiene buena pinta :)

Compartir Editar Eliminar

Respuesta1

información relacionada