mysql - AWS Lambda Invoke 不执行 lambda 函数

Question

我创建了 4 个 Lambda 函数来处理将写入 MySQL 表的信息。前三个函数分别只是选择、插入和更新一条MYSQL表记录。

然后我创建了第四个函数来接受记录详细信息作为事件参数的一部分。此函数将首先尝试通过调用第一个 lambda 函数来选择记录，如果找到它，将使用更新 lambda 函数更新表中的记录。如果没有找到，它将调用插入函数来添加记录。我在操作 MySQL 表的 3 个函数上使用 pool.query。我还使用 lambda.invoke 从第四个函数调用这三个函数。

通过将记录详细信息作为参数传递，我能够在本地成功测试第 4 个函数，它能够成功调用三个 Lambda 函数并更新 mySQL 表记录。我遇到的问题是，当我在 AWS Lambda 中上传函数时，它不会调用这三个函数中的任何一个。我在日志中没有看到任何错误，所以我不知道如何检查问题出在哪里。这是调用其他函数的 ,y 代码:

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

var err = null;
var payload = {
        qryString : event.qryString,
        record: event.updaterecord,
        dbConfigPool : event.dbConfigPool
           }

var params = {
  FunctionName: 'getInventory', 
  Payload: JSON.stringify(payload) 
}
console.log(' before invoke ' + JSON.stringify(params) )
lambda.invoke(params, function(err, data) {
console.log(' aftr invoke ' + JSON.stringify(params) )
  if (err) {
    console.log('err ' + err, err.stack); // an error occurred
    event.message = err + ' query error';
  }
  else    { 
      console.log('success' + JSON.stringify(data));   
      console.log(' status code ' + JSON.stringify(data.StatusCode));
      console.log(' Payload ' + JSON.stringify(JSON.parse(data.Payload)));
      var rowsTemp = JSON.parse(data.Payload);
      var rows = rowsTemp.data;
      if (!rowsTemp.recordExist) {
          console.log('insert')
            // Update inventory record only if quantity is not negative
          var newQuantity = 0
      newQuantity = parseFloat(event.updaterecord.quantity);
      if (Math.sign(newQuantity) === 1) {
        var payload = {
                    record: event.updaterecord,
                    dbConfigPool : event.dbConfigPool
                       }

        console.log('insert' + JSON.stringify(payload));
        var params = {
          FunctionName: 'insertInventory', 
          Payload: JSON.stringify(payload) 
        }
            lambda.invoke(params, function(err, data) {
              if (err) console.log(err, err.stack); // an error occurred
              else     console.log(data);           // successful response
            });
        }

  }
  else {
      newQuantity = 0
      newQuantity = parseFloat(event.updaterecord.quantity) + parseFloat(rows[0].quantity);
      if (Math.sign(newQuantity) === 1) {
      event.updaterecord.quantity = newQuantity;
      } else {
        // Set to zero if the result is negative
      event.updaterecord.quantity = 0;
      }
      console.log('value ' + JSON.stringify(newQuantity) + ' updaterecord' + JSON.stringify(event.updaterecord.quantity) );
      var payload = {
                    qryString : event.qryString,
                    record: event.updaterecord,
                    dbConfigPool : event.dbConfigPool
                       }
      console.log('update' + JSON.stringify(payload));
        var params = {
          FunctionName: 'updateInventory', 
          Payload: JSON.stringify(payload) 
        }
        console.log(' before invoke ' + JSON.stringify(params) )
        lambda.invoke(params, function(err, data) {
        console.log(' after invoke ' + JSON.stringify(params) )
          if (err) {
            console.log('err ' + err, err.stack); // an error occurred
            event.message = err + ' query error';
          } else {
              console.log(data);
          } // else
        }); // lambda invoke
  }
  }        // successful response
});

console.log(' end of function');
var completed = true;
context.callbackWaitsForEmptyEventLoop = false; 
callback(null, completed);

}

如果代码很长，我们深表歉意。但我想证明我确实放置了一些 console.logs 来监控它经过的地方。 cloudwatch 日志仅显示第一个 lambda.invoke 之前的第一条消息，然后显示函数结束的最后一条消息。

我也没有在 cloudwatch 中看到已调用的三个函数的任何日志条目。

06/17 好的，因为我仍然无法完成这项工作，所以我将代码简化为以下内容:

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

var err = null;
var updatedRecord = false;
var responseDetail = {};
var payload = {
        qryString : event.qryString,
        record: event.updaterecord,
        dbConfigPool : event.dbConfigPool
           }

var params = {
  FunctionName: 'getInventory', 
  Payload: JSON.stringify(payload) 
}
console.log(' before invoke ' + JSON.stringify(params));
lambda.invoke(params, function(err, data) {
  if (err) {
  event.message = err + ' query error';
  callback(err,event.message);
  }
  else    { 

  console.log('success' + JSON.stringify(data));   
  console.log(' status code ' + JSON.stringify(data.StatusCode));
  console.log(' Payload ' + JSON.stringify(JSON.parse(data.Payload)));
  callback(null, data);

  }        // successful response
});

console.log(' end of function');
//    var completed = true;
//    context.callbackWaitsForEmptyEventLoop = false; 
//    callback(null, completed);

}

但是，当我进行测试时，函数超时。我还为附加到函数的角色提供了完整的 Lambda 和 RDS 访问权限。

Answer 1

首先 - 欢迎来到回调 hell !我稍后会回到这个。

这是调用 lambda 函数的简单代码。

var params = {
  FunctionName: 'LAMBDA_FUNCTION_NAME', /* required */
};
lambda.invoke(params, function(err, data) {
  if (err) {
   console.log(err, err.stack); // an error occurred
  }
  else {
   console.log(data);           // successful response
  }
});

lambda.invoke 函数有两个参数(params、function(err,data){..})。第一个是一个简单的 JSON 对象。第二个是函数——回调函数。当 lambda.invoke(你可以认为是 LAMBDA_FUNCTION_NAME)的执行结束时，这个函数将被“回调”。如果发生错误，它将“存储”在 err 变量中，否则返回的数据将存储在 data 变量中(这不是正确的解释，但我试图保留它这里很简单)。

当你想一个接一个地调用两个 lambda 函数时会发生什么？

var params1 = {
  FunctionName: 'LAMBDA_FUNCTION_1_NAME', /* required */
};
lambda.invoke(params1, function(err, data) {
  if (err) {
   console.log(err, err.stack); // an error occurred
  }
  else {
   console.log('Lambda function 1 invoked!');
   console.log(data);           // successful response
  }
});
var params2 = {
  FunctionName: 'LAMBDA_FUNCTION_2_NAME', /* required */
};
lambda.invoke(params2, function(err, data) {
  if (err) {
   console.log(err, err.stack); // an error occurred
  }
  else {
   console.log('Lambda function 2 invoked!');
   console.log(data);           // successful response
  }
});
console.log('I am done!');

根据 LAMBDA_FUNCTION_1_NAME 和 LAMBDA_FUNCTION_2_NAME 的执行时间，您会看到不同的输出，例如:

Lambda function 1 invoked!
I am done!

或

Lambda function 1 invoked!
Lambda function 2 invoked!
I am done!

甚至

Lambda function 1 invoked!
I am done!
Lambda function 2 invoked!

这是因为您正在调用 lambda.invoke，然后(无需等待)您再次调用 lambda.invoke。在那之后(当然不用等待)之前结束你调用的函数 console.log('I am done!');

您可以通过将每个函数放在前一个函数的回调中来解决这个问题。像这样:

var params1 = {
  FunctionName: 'LAMBDA_FUNCTION_1_NAME', /* required */
};
lambda.invoke(params1, function(err, data) {
  if (err) {
   console.log(err, err.stack); // an error occurred
  }
  else {
   console.log('Lambda function 1 invoked!');
   console.log(data);           // successful response
   var params2 = {
    FunctionName: 'LAMBDA_FUNCTION_2_NAME', /* required */
   };
   lambda.invoke(params2, function(err, data) {
      if (err) {
       console.log(err, err.stack); // an error occurred
      }
      else {
       console.log('Lambda function 2 invoked!');
       console.log(data);           // successful response
       console.log('I am done!');
      }
    });
  }
});

这样你的输出将是:

Lambda function 1 invoked!
Lambda function 2 invoked!
I am done!

但是如果你想一个接一个地调用 3 个或更多函数，你最终会得到嵌套代码。这就是回调 hell 。你可以用那种方式重写你的代码。但在我看来，检查 waterfall async library 是个好主意。

async.waterfall([
    function(callback) {
        callback(null, 'one', 'two');
    },
    function(arg1, arg2, callback) {
      // arg1 now equals 'one' and arg2 now equals 'two'
        callback(null, 'three');
    },
    function(arg1, callback) {
        // arg1 now equals 'three'
        callback(null, 'done');
    }
], function (err, result) {
    // result now equals 'done'
})

伪代码应该是这样的:

async.waterfall([
    function(callback1) {
        var params1 = {
            FunctionName: 'LAMBDA_FUNCTION_1_NAME', /* required */
        };
        lambda.invoke(params1, function(err, data) {
            if (err) {
                console.log(err, err.stack); // an error occurred
            }
            else {
                console.log('LAMBDA_FUNCTION_1_NAME finished!');
                callback1(null,data);
            }
        });
    },
    function(result_from_function_1, callback2) {
        console.log(result_from_function_1); // outputs result from LAMBDA_FUNCTION_1_NAME
        var params2 = {
            FunctionName: 'LAMBDA_FUNCTION_2_NAME', /* required */
        };
        lambda.invoke(params2, function(err, data) {
            if (err) {
                console.log(err, err.stack); // an error occurred
            }
            else {
                console.log('LAMBDA_FUNCTION_2_NAME finished!');
                callback2(null,data); 
            }
        });
    },
    function(result_from_function_2, callback3) {
        console.log(result_from_function_2); // outputs result from LAMBDA_FUNCTION_2_NAME
        var params3 = {
            FunctionName: 'LAMBDA_FUNCTION_3_NAME', /* required */
        };
        lambda.invoke(params3, function(err, data) {
            if (err) {
                console.log(err, err.stack); // an error occurred
            }
            else {
                console.log('LAMBDA_FUNCTION_3_NAME finished!');
                callback3(null,data);
            }
        });
    }
], function (err, result) {
    // result now equals LAMBDA_FUNCTION_3_NAME result
})

请注意，所有回调(callback1、callback2 和 callback3)只能使用名称“callback”。为了更好地理解，我更改了它们的名称。