Question

我不知道这是否与父 Lambda 是 node.js 运行时而子代是 Python 3.8 的事实有关，但我遇到了一些奇怪的行为，我无法弄清楚出了什么问题...

tldr：仅当父 lambda '睡眠'（调用 setTimeout()）100 毫秒或更长时间时，才会调用子 lambda。

我有两个简单的 AWS Lambda 函数。一个是用 JS（node.js 运行时）编写的，另一个是用 Python (3.8) 编写的。设置很简单。父 node.js 函数调用子 python 函数。调用是异步的，父级不必等待子级返回。父节点必须是 node.js，子节点必须是 python 3.8。

我的观察是，除非父 lambda“休眠”至少 100 毫秒，否则不会调用子 python lambda。我知道这听起来很奇怪，但我不确定我做错了什么，并花了几天时间试图解决这个问题（毫无疑问这真的很简单......）。

我编写了一个“睡眠”函数（显示在 node.js 代码的顶部），它在响应从父函数返回给调用者之前被调用。我知道 .invoke 回调中的代码将在父函数返回后调用，这只是为了调试目的。

这是 node.js 父 Lambda：

var aws = require('aws-sdk')
var lambda = new aws.Lambda()

function sleep(ms) {
  return new Promise((resolve) => {
    setTimeout(resolve, ms);
  });
}  


exports.handler = async (event) => {
    const payload = {
        message: "Hey there",
        
    }
    var params = {
    FunctionName: 'ChildLambda', // the lambda function we are going to invoke
    InvocationType: 'Event', // RequestResponse is sync, Event Async
    LogType: 'Tail',
    Payload: JSON.stringify(payload)
  };
    lambda.invoke(params, function(err, data) {
        console.log("Invoked Lambda...")
        if (err) {
            console.log(err)
        } else if (data) {
            console.log('Data: ', data)
        }
        console.log("Lambda done")
        
    })
    // await sleep(100)
    const response = { 
        "isBase64Encoded": false,
        "statusCode": 202,
        "headers": {},
        "body": "HEY FROM LAMBDA"
    }
    return response;
};

这里是 Python 子 Lambda：

import requests
import json

def main(event, context):
    print("IN THE SECOND LAMBDA")
    response = {
        "statusCode": 200,
        "headers": {"my_header": "my_value"},
        "body": "hello from second lambda",
        "isBase64Encoded": False,
    }
    return response

如果从父函数中删除 sleep(100) 调用，则不会调用子函数。我知道这一点，因为 CloudWatch 日志中没有显示任何内容。如果您将传递给 sleep() 的参数设置为小于 100 毫秒，则不会调用子 lambda。异步或同步调用子函数（通过将父函数中的"Event"中的"RequestResponse"替换为params不会改变任何东西，以上仍然成立。

这种奇怪行为的原因是什么？我做错了什么？

编辑 @jellycsc 链接到调用 invoke 命令的替代方法：

var invoke  = lambda.invoke(params).promise()
    invoke.then(function(data) {
        console.log('Success');
    }).catch(function(err) {
        console.log(err);
    });

不幸的是，这并没有解决问题，并且只有在计时器设置为 100 毫秒或更长时间时才会调用 invoke 命令。

Answer 1

只需等到 invoke 操作完成，然后完成 lambda 函数。

exports.handler = async (event) => {
  const payload = {
    message: "Hey there",

  }
  var params = {
    FunctionName: 'ChildLambda', // the lambda function we are going to invoke
    InvocationType: 'Event', // RequestResponse -  to get response from ChildLambda, Event - don't care the response (or error...)
    LogType: 'Tail',
    Payload: JSON.stringify(payload)
  };

  try {
    console.log("Invoked Lambda...")
    const data = await lambda.invoke(params).promise() // wait until invoke successfully
    console.log('Data: ', data) // data maybe empty - {} when InvocationType is Event
    console.log("Lambda done")
  
    return {
      "isBase64Encoded": false,
      "statusCode": 202,
      "headers": {},
      "body": "HEY FROM LAMBDA"
    }
  } catch (error) {
    // handle error
    console.log("Error", error);
    return {
      "isBase64Encoded": false,
      "statusCode": 500, // return error response
      "headers": {},
      "body": error.message
    }
  }
};

使用 Node.JS AWS Lambda 调用 Python AWS Lambda 函数

1 个答案: