从另一个 lambda 异步调用 aws lambda

Question

我需要从另一个 lambda 异步调用 aws lambda。我有同步调用的工作代码。

exports.handler = (event, context, callback) => {
    var aws = require('aws-sdk');
    var lambda = new aws.Lambda({
        region: 'myregion' //change to your region
    });
    console.log("lambda invoke started");
    lambda.invoke({
        FunctionName: 'testLambda',
        Payload: JSON.stringify(event, null, 2) // pass params
    }, function (error, data) {
        if (error) {
            console.log("error");
            callback(null, 'hello world');
        }
        else {
            console.log("lambda invoke end");
            callback(null, 'hello world');
        }
    });
}

但在我的例子中，'testLambda' 是一个时间函数。因为我需要在调用 'testLambda' 函数后立即退出。然后代码更新成这样

exports.handler = (event, context, callback) => {
    var aws = require('aws-sdk');
    var lambda = new aws.Lambda({
        region: 'myregion' //change to your region
    });
    console.log("lambda invoke started");
    lambda.invoke({
        FunctionName: 'testLambda',
        Payload: JSON.stringify(event, null, 2) // pass params
    });
    console.log("lambda invoke end");
    callback(null, 'hello world');
}

它 returns 消息正确。但是我的 'testLambda' 函数没有被调用（没有为测试 lambda 生成云监视日志）。与此代码相关的问题是什么。

Answer 1

根据 the Lambda invoke() documentation，您将看到默认情况下使用 RequestResponse 调用类型调用 Lambda 函数。要异步调用该函数，您需要指定 Event 调用类型，如下所示：

lambda.invoke({
    FunctionName: 'testLambda',
    InvocationType: 'Event',
    Payload: JSON.stringify(event, null, 2)
},function(err,data){});

Answer 2

我在 AWS Lambda 中使用当前最新的 node.js 8.10 版本。
在我使用 async/await 机制之前，第二个 lambda 没有执行（并且从未调用过回调函数）。
所以处理函数必须是异步的，并且 'lambda.invoke' 调用用 Promise.

包装

这是我的工作代码：

function invokeLambda2(payload) {
    const params = {
        FunctionName: 'TestLambda2',
        InvocationType: 'Event',
        Payload: JSON.stringify(payload)
    };

    return new Promise((resolve, reject) => {

        lambda.invoke(params, (err,data) => {
            if (err) {
                console.log(err, err.stack);
                reject(err);
            }
            else {
                console.log(data);
                resolve(data);
            }
        });     
    });
}


exports.handler = async (event, context) => {
    const payload = {
        'message': 'hello from lambda1'
    };
    await invokeLambda2(payload);
    context.done();
};

请注意，处理程序不会等待第二个 lambda 退出，只会触发它并调用回调函数。

您还可以 return 处理程序中的 Promise，不必再使用 await功能。

使用 Promises 和 async/await 时不需要任何导入，除了：

const AWS = require('aws-sdk');
const lambda = new AWS.Lambda();

Answer 3

这就是我在 Express.js

中的使用方式


var express = require("express");
var router = express.Router();

const asyncMiddleware = fn =>
  (req, res, next) => {
    Promise.resolve(fn(req, res, next))
      .catch(next);
  };

const invokeLambda = async (params) => {
  const data = await lambda.invoke(params).promise();
  return JSON.parse(data.Payload);
}


router.get('/test', asyncMiddleware(async (req, res, next) => {
  const params = {
    FunctionName: SOMETHING_LAMBDA_ARN,
    Payload: JSON.stringify(req.body)
  };
  const result = await invokeLambda(params);
  res.send(result);
}));

Answer 4

我想要一个与上面类似的解决方案。虽然现在建议在 lambda.invoke 上使用多个 lambda 函数时使用步进函数，但我使用以下代码片段从我的基本 lambda 函数异步调用另外两个 lambda 函数。

var AWS = require('aws-sdk');
AWS.config.region = 'ap-southeast-1';
var lambda = new AWS.Lambda();

exports.handler = async(event) => {
   await invokeLambda(event);
   
   const response = {
        statusCode: 200,
        body: JSON.stringify('success'),
   };
   
   return response;
};

//Invoke Multiple Lambda functions
  async function invokeLambda(event) {
    const function1 = {
        FunctionName: 'dev-test-async-lambda-1',
        InvocationType: 'Event',
        Payload: JSON.stringify(event)
    };

    const function2 = {
        FunctionName: 'dev-test-async-lambda-2',
        InvocationType: 'Event',
        Payload: JSON.stringify(event)
    };
    
    await lambda.invoke(function1).promise();
    await lambda.invoke(function2).promise();

}

让我知道我是否可以改进它。

Answer 5

参考，而不是将 lambda.invoke() 包装在 Promise 中，您可以直接使用 lambda.invoke().promise() 并执行如下操作：（在 Node.js 12.x)

exports.handler = async (event) => {

    const payload = 'hello from lambda 1';

    const params = {
        FunctionName: 'lambda2',
        InvocationType: 'Event',
        Payload: JSON.stringify(payload),
    };

    const LambdaPromise = (params) => lambda.invoke(params).promise();

    const responseFromLambda2 = await LambdaPromise(params);

    return responseFromLambda2; //this should return {StatusCode: 202, Payload: ''}
};

从另一个 lambda 异步调用 aws lambda

invoke aws lambda from another lambda asynchronously

asynchronous

asynccallback

amazon-web-services

node.js

aws-lambda