Nodejs - 从另一个lambda函数中调用AWS.Lambda函数

Question

我有以下函数用于从我的代码中调用Lambda函数.

但是,当我尝试在Lambda函数中使用它时,我收到以下错误:

AWS lambda undefined 0.27s 3 retries] invoke({ FunctionName: 'my-function-name',
  InvocationType: 'RequestResponse',
  LogType: 'Tail',
  Payload: <Buffer > })

如何在Lambda函数中调用Lambda函数？

我的功能:

'use strict';

var AWS = require("aws-sdk");

var lambda = new AWS.Lambda({
    apiVersion: '2015-03-31',
    endpoint: 'https://lambda.' + process.env.DYNAMODB_REGION + '.amazonaws.com',
    logger: console
});

var lambdaHandler = {};

// @var payload - type:string
// @var functionName - type:string
lambdaHandler.invokeFunction = function (payload, functionName, callback) {

    var params = {
        FunctionName: functionName, /* required */
        InvocationType: "RequestResponse",
        LogType: "Tail",
        Payload: new Buffer(payload, 'utf8')
    };

    var lambdaRequestObj = lambda.invoke(params);

    lambdaRequestObj.on('success', function(response) {
        console.log(response.data);
    });

    lambdaRequestObj.on('error', function(response) {
        console.log(response.error.message);
    });

    lambdaRequestObj.on('complete', function(response) {
        console.log('Complete');
    });

    lambdaRequestObj.send();

    callback();
};

module.exports = lambdaHandler;

Answer 1

使用aws-sdk每个Lambda中可用的Lambda函数从另一个Lambda函数中调用Lambda函数非常简单.

我建议先从简单的东西开始.
这是lambda内部调用的"Hello World":

Lambda_ALambda_B 使用Payload包含单个参数的调用name:'Alex'.
Lambda_B用Payload回应:"Hello Alex".

首先创建Lambda_B一个希望将name 财产 上的event参数
,并响应与要求"Hello "+event.name:

Lambda_B

exports.handler = function(event, context) {
  console.log('Lambda B Received event:', JSON.stringify(event, null, 2));
  context.succeed('Hello ' + event.name);
};

确保你给Lambda_B和Lambda_A相同的作用.
例如:创建一个名为且lambdaexecute同时具有AWSLambdaExecute 和 AWSLambdaBasicExecutionRole(由于某种原因两者都需要)的角色:

Lambda_A

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

exports.handler = function(event, context) {
  var params = {
    FunctionName: 'Lambda_B', // the lambda function we are going to invoke
    InvocationType: 'RequestResponse',
    LogType: 'Tail',
    Payload: '{ "name" : "Alex" }'
  };

  lambda.invoke(params, function(err, data) {
    if (err) {
      context.fail(err);
    } else {
      context.succeed('Lambda_B said '+ data.Payload);
    }
  })
};

保存这两个Lambda函数后,测试运行Lambda_A:

一旦你有基本的 intra-lambdda调用工作,你可以很容易地扩展它来调用更精细的Lambda函数.

您必须记住的主要事情是为所有功能设置适当ARN Role的.

Answer 2

正如2016年12月3日,你可以简单地使用AWS阶跃函数把lambda函数Lambda_B作为的后续步骤,Lambda_A.

使用AWS Step Functions,您可以将应用程序定义为状态机,这是一系列共同捕获应用程序行为的步骤.状态机中的状态可以是任务,顺序步骤,并行步骤,分支路径(选择)和/或定时器(等待).任务是工作单元,此工作可由AWS Lambda函数,任何类型的Amazon EC2实例,容器或内部服务器执行 - 可以为可与Step Functions API通信的任何任务分配任务.

所以以下状态机应该满足您的需求.

这是与状态机相对应的代码.

{
  "Comment": "A simple example of the Amazon States Language using an AWS Lambda Function",
  "StartAt": "Lambda_A",

  "States": {
    "Lambda_A": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:REGION:ACCOUNT_ID:function:FUNCTION_NAME",
      "Next": "Lambda_B"
    },
    "Lambda_B":{
      "Type": "Task",
      "Resource": "arn:aws:lambda:REGION:ACCOUNT_ID:function:FUNCTION_NAME",
      "End": true
    }

  }
}

此外,您可以在状态机中添加更复杂的逻辑,例如并行步骤和捕获故障.它甚至记录每次执行的细节,这使得调试成为一种更好的体验,特别是对于lambda函数.

Answer 3

使用 AWS.Lambda Promise 接口调用 lambda 比aws-sdk使用回调更容易。

此示例函数允许您从另一个 lambda 同步调用 lambda（它使用'RequestResponse'as InvocationType，因此您可以获得调用的 lambda 返回的值）。

如果使用'Event'（用于异步调用），则无法获取被调用的 lambda 返回的值，只能检测 lambda 是否可以成功调用。它适用于不需要从调用的 lambda 获取返回值的情况。

//
// Full example of a lambda that calls another lambda
//
// (create a lambda in AWS with this code)
//
'use strict';

//
// Put here the name of the function you want to call
//
const g_LambdaFunctionName = 'PUT_HERE_THE_INVOKED_LAMBDA_NAME'; // <======= PUT THE DESIRED VALUE

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

//
// Expected use:
//
//   // (payload can be an object or a JSON string, for example)
//   let var = await invokeLambda(lambdaFunctionName, payload);
//
const invokeLambda = async (lambdaFunctionName, payload) => {

   console.log('>>> Entering invokeLambda');

   // If the payload isn't a JSON string, we convert it to JSON
   let payloadStr;
   if (typeof payload === 'string')
   {
       console.log('invokeLambda:  payload parameter is already a string: ', payload);
       payloadStr = payload;
   }
   else
   {
       payloadStr = JSON.stringify(payload, null, 2);
       console.log('invokeLambda: converting payload parameter to a string: ', payloadStr);
   }

   let params = {
       FunctionName   : lambdaFunctionName,               /* string type, required */
       // ClientContext  : '',                               /* 'STRING_VALUE' */
       InvocationType : 'RequestResponse',                /* string type: 'Event' (async)| 'RequestResponse' (sync) | 'DryRun' (validate parameters y permissions) */
       // InvocationType : 'Event',

       LogType        : 'None',                           /* string type: 'None' | 'Tail' */
       // LogType        : 'Tail',
       Payload        : payloadStr,                       /* Buffer.from('...') || 'JSON_STRING' */ /* Strings will be Base-64 encoded on your behalf */
       //  Qualifier      : '',                             /* STRING_VALUE' */
   };

   //
   // TODO/FIXME: add try/catch to protect this code from failures (non-existent lambda, execution errors in lambda)
   //
   const lambdaResult = await lambda.invoke(params).promise();

   console.log('Results from invoking lambda ' + lambdaFunctionName + ': ' , JSON.stringify(lambdaResult, null, 2) );

   // If you use LogType = 'Tail', you'll obtain the logs in lambdaResult.LogResult.
   // If you use 'None', there will not exist that field in the response.
   if (lambdaResult.LogResult)
   {
       console.log('Logs of lambda execution: ',  Buffer.from(lambdaResult.LogResult, 'base64').toString());
   }

   console.log('invokeLambdaSync::lambdaResult: ', lambdaResult);

   console.log('<<< Returning from invokeLambda, with lambdaResult: ', JSON.stringify(lambdaResult, null, 2));

   // The actual value returned by the lambda it is lambdaResult.Payload
   // There are other fields (some of them are optional)
   return lambdaResult;
};

//
// We'll assign this as the calling lambda handler.
//
const callingFunc = async (event) => {

   //
   // in this example We obtain the lambda name from a global variable
   //
   const lambdaFunctionName = g_LambdaFunctionName;
   
   // const payload            = '{"param1" : "value1"}';
   const payload            = event;

   //
   // invokeLambda has to be called from a async function
   // (to be able to use await)
   //
   const result = await invokeLambda(lambdaFunctionName, payload);

   console.log('result: ', result);
};

// Assing handler function
exports.handler = callingFunc;

请注意，您应该在invokeLambdaawait之前使用：

...
    //
    // Called from another async function
    //
    const result = await invokeLambda(lambdaFunctionName, payload);
...

一些带有附加信息的相关链接：

• 有关调用的 AWS 参考invoke： https: //docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Lambda.html#invoke-property
• 有关调用 lambda 的 AWS 文档：https://docs.aws.amazon.com/lambda/latest/dg/API_Invoke.html
• AWS 中的 Promise 接口： https://aws.amazon.com/es/blogs/compute/node-js-8-10-runtime-now-available-in-aws-lambda/
• 示例（西班牙语解释）：https://www.it-swarm.dev/es/node.js/invocar-aws-lambda-desde-otra-lambda-de-forma-asincronica/826852446/
• 处理错误，避免 lambda 之间的耦合：https://www.rehanvdm.com/serverless/13-aws-lambda-design-considerations-you-need-to-know-about-part-2/index.html

Answer 4

@nelsonic 提到的一切都是正确的，除了角色。

我试着选择他上面提到的角色：

• AWSLambdaExecute
• AWSLambdaBasicExecutionRole

但它不允许我调用我的另一个 lambda 函数，所以我将角色更改为以下内容：

• AWSLambda角色
• AWSLambdaBasicExecutionRole

背后的原因是AWSLambdaExecute仅提供 Put、Get 访问 S3 和完全访问 CloudWatch Logs。但 AWSLambdaRole为 AWS Lambda 服务角色提供默认策略。 如果您遵守其权限政策，它将谈论invokeFunction

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "lambda:InvokeFunction"
            ],
            "Resource": [
                "*"
            ]
        }
    ]
}

注意：可以在没有AWSLambdaBasicExecutionRole策略的情况下继续进行，因为它只启用了云中的日志记录。但是AWSLambdaRole是绝对必要的。