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

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

我建议先从 simple 开始。
这是lambda内部调用的“Hello World”：

Lambda_A调用Lambda_B Payload包含单个参数name:'Alex' Lambda_B以有效负载回复："Hello Alex"。

lambda invoke

首先创建需要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-role-for-intra-lambda-execution

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：

lambda invoke-lambda_a-execution-result

在基本 intra-lambdda调用工作之后，您可以轻松扩展它以调用更精细的Lambda函数。

要记住的主要内容是 为所有功能设置适当的ARN Role 。

Answer 2

自2016年12月3日起，您只需使用AWS Step功能将Lambda函数 Lambda_B 作为 Lambda_A 的连续步骤。

使用AWS Step Functions，您可以将应用程序定义为状态机器，一起捕捉行为的一系列步骤应用程序。状态机中的状态可以是任务，顺序步骤，并行步骤，分支路径（选择）和/或定时器（等待）。任务是工作单元，此工作可由AWS Lambda执行函数，任何类型的Amazon EC2实例，容器或on 驻地服务器 - 可以与步骤功能通信的任何东西可以为API分配任务。

因此以下状态机应满足您的需求。

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

some_subroutine(a(:,1))

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

Answer 3

@nelsonic提到的所有内容都是正确的，除了角色。

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

AWSLambdaExecute
AWSLambdaBasicExecutionRole

但它不允许我调用我的其他lambda函数，所以我将角色更改为如下：

AWSLambdaRole
AWSLambdaBasicExecutionRole

背后的原因是 AWSLambdaExecute ，只有提供了Put，获取对S3的访问权限以及对CloudWatch Logs的完全访问权限。但 AWSLambdaRole 为AWS Lambda服务角色提供默认策略。 如果您遵守其权限政策，它将讨论 invokeFunction

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

注意：可以在没有 AWSLambdaBasicExecutionRole 策略的情况下继续进行，因为它只会使云中的日志记录无法进行任何操作。但 AWSLambdaRole 是绝对必要的。

Answer 4

在aws-sdk中使用AWS调用lambda较使用回调更容易。

该示例函数使您可以从另一个lambda同步调用一个lambda（它使用'RequestResponse'作为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;

请注意，您应在 invokeLambda 之前使用await：

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

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

有关invoke呼叫的AWS参考：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中的Promises接口： 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

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

4 个答案:

Lambda_B

Lambda_A