为什么 AWS Lambda 函数会为单个事件多次调用？

Question

我正在尝试创建执行以下过程的 AWS Lambda 函数。

• 接收 S3“放置”事件
• 从 S3 获取文件 A
• 从调用 lambda 的 S3 获取 fileB
• 仅启动一个 EC2 实例
• 为新 EC2 实例创建标签

问题：多个 (5) 实例意外启动。

成功创建了一个实例，但同时启动了 4 个其他实例。 总共启动了 5 个实例。

日志

在此函数的日志流中，我找到了 4 个用于此调用的流。 每个 Stream 都没有显示任何错误或异常，但似乎该函数是重复执行的。

审判

我猜是函数超时了，然后重新运行。

然后，我将Timeout从 5s 更改为 60s 并将文件放在 S3 上。 它以某种方式起作用。 只出现了2个Log Streams，第一个显示函数只执行了一次，第二个显示函数执行了两次。 已启动实例数为 3。

但是，我不知道为什么会启动多个（3）个实例。

欢迎任何意见！ 先感谢您 ：-）

我的 Lambda 函数

我的 Lambda 函数如下。 （简化了隐藏凭证信息，但不会丢失其基本结构）

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

function composeParams(data, config){
  var block_device_name = "/dev/xvdb";
  var security_groups = [
    "MyGroupName"
  ];
  var key_name = 'mykey';
  var security_group_ids = [
    "sg-xxxxxxx"
  ];
  var subnet_id = "subnet-xxxxxxx";

  // Configurations for a new EC2 instance
  var params = {
    ImageId: 'ami-22d27b22',      /* required */
    MaxCount: 1,                  /* required */
    MinCount: 1,                  /* required */
    KeyName: key_name,
    SecurityGroupIds: security_group_ids,
    InstanceType: data.instance_type,
    BlockDeviceMappings: [
      {
        DeviceName: block_device_name,
        Ebs: {
          DeleteOnTermination: true,
          Encrypted: true,
          VolumeSize: data.volume_size,
          VolumeType: 'gp2'
        }
      }
    ],
    Monitoring: {
      Enabled: false              /* required */
    },
    SubnetId: subnet_id,
    UserData: new Buffer(config).toString('base64'),
    DisableApiTermination: false,
    InstanceInitiatedShutdownBehavior: 'stop',
    DryRun: data.dry_run,
    EbsOptimized: false
  };

  return params;
}

exports.handler = function(event, context) {
  // Get the object from the event
  var s3 = new AWS.S3({ apiVersion: '2006-03-01' });
  var bucket = event.Records[0].s3.bucket.name;
  var key = event.Records[0].s3.object.key;

  // Get fileA
  var paramsA = {
    Bucket: bucket,
    Key: key
  };
  s3.getObject(paramsA, function(err, data) {
    if (err) {
      console.log(err);
    } else {
      var dataA = JSON.parse(String(data.Body));

      // Get fileB
      var paramsB = {
        Bucket: bucket,
        Key: 'config/config.yml'
      };
      s3.getObject(paramsB, function(err, data) {
        if (err) {
          console.log(err, err.stack);
        } else {
          var config = data.Body;
          /* Some process */

          // Launch EC2 Instance
          var ec2 = new AWS.EC2({ region: REGION, apiVersion: '2015-04-15' });
          var params = composeParams(dataA, config);
          ec2.runInstances(params, function(err, data) {
            if (err) {
              console.log(err, err.stack);
            } else {
              console.log(data);

              // Create tags for instance
              for (var i=0; i<data.Instances.length; i++){
                var instance = data.Instances[i];
                var params = {
                  Resources: [                /* required */
                    instance.InstanceId
                  ],
                  Tags: [                     /* required */
                    {
                      Key: 'Name',
                      Value: instance_id
                    },
                    {
                      Key: 'userID',
                      Value: dataA.user_id
                    }
                  ],
                  DryRun: dataA.dry_run
                };
                ec2.createTags(params, function(err, data) {
                  if (err) {
                    console.log(err, err.stack);
                  } else {
                    console.log("Tags created.");
                    console.log(data);
                  }
                });
              }
            }
          });
        }
      });
    }
  });
};

Answer 1

解决了。

添加context.succeed(message); 嵌套回调的最后一部分防止函数的重复执行。

            ec2.createTags(params, function(err, data) {
              if (err) {
                console.log(err, err.stack);
                context.fail('Failed');
              } else {
                console.log("Tags created.");
                console.log(data);
                context.succeed('Completed');
              }
            });

Answer 2

为每次调用检查 cloudwatch 事件的 context.aws_request_id 值。 如果是

1. 与重试相同，因为 aws 函数引发了一些错误。 使您的 lambda 成为幂等的
2. 与aws 的连接超时不同
   拉姆达客户端。 检查 aws 客户端配置请求超时和
   连接超时值。

Answer 3

我在使用较新的运行时（Node.JS v4.3）时遇到了同样的问题。 称呼

context.callbackWaitsForEmptyEventLoop = false;

打电话之前

callback(...)

Answer 4

最大事件年龄

当函数在执行前返回错误时，Lambda 会将事件返回到队列中，并在默认情况下最多 6 小时内尝试再次运行该函数。 使用最长事件期限，您可以将队列中事件的生命周期配置为 60 秒到 6 小时。 这允许您根据事件年龄删除任何不需要的事件。

最大重试次数

当函数在执行后返回错误时，默认情况下 Lambda 会尝试再运行两次。 使用 Maximum Retry Attempts，您可以自定义从 0 到 2 的最大重试次数。这使您可以选择以更少或不重试的方式继续处理新事件。

在Configuration > Asynchronous invocation > Retry Attempts 下，您可以将其设置为0-2

来源： https : //aws.amazon.com/about-aws/whats-new/2019/11/aws-lambda-supports-max-retry-attempts-event-age-asynchronous-invocations/