在AWS Lambda中使用Promise.all（）

Question

我不明白为什么我的promise.all（）不能在Lambda中执行，而在开发中已经起作用了。

在AWS Lambda上，由于Promise.all（）未完成，并且SQS队列中没有收到新消息，因此已经超时。

但是，console.log(promises)返回了：2017-01-29T22:55:46.191Z 0e82eeaf-e676-11e6-b69d-73a6bbd86272 [ Promise { <pending> } ]

var url = require('url');
var AWS = require('aws-sdk');
// var Promise = require("bluebird");

exports.handler = function (event, context, callback) {

    AWS.config = {
        region: 'us-east-1',
        apiVersions : {
            sqs: '2012-11-05'
        }
    };

    if (typeof Promise === 'undefined') {
        AWS.config.setPromisesDependency(require('bluebird'));
    }

    var sqs = new AWS.SQS(); // système de queue
    var date = new Date();

    var knex = require('knex')({
        client: 'mysql',
        connection: {
            host : event.database.host,
            user : event.database.user,
            password : event.database.pwd,
            database : event.database.name
        }
    });

    var sqsQueueUrl = event.sqsQueueUrl;
    var keywords = event.keywords;

    knex.select('keywords').from('keyword')
        .timeout(1000)
        .then(function(results) 
        {
            var keywordsInDbArray = returnArrayWithOnlyKeywords(results);

            var keywordsWillBeStored = [];

            for (var i in keywords) 
            {
                var isInDb = keywordsInDbArray.indexOf(keywords[i]);

                if(isInDb == -1)
                    keywordsWillBeStored.push({
                        keywords: keywords[i],
                        'created_at': date, 
                        'updated_at': date
                    });
            }
            if(keywordsWillBeStored.length > 0)
            {
                knex.batchInsert('keyword', keywordsWillBeStored, keywordsWillBeStored.length)
                    .then(function(firstId) 
                    { 
                        var newKeywordsStored = dataStoredInDb(firstId, keywordsWillBeStored);
                        console.log(newKeywordsStored);

                        sendKeywordInqueue(newKeywordsStored);
                    })
                    .catch(function(error) 
                    { 
                        console.error(error);
                        context.fail(error);
                        knex.destroy();
                    });
            }
            else
            {
                context.succeed('Aucun nouveau keyword a enregistré');
            }
        })
        .catch(function(error) 
        {
            console.error(error);
            context.fail(error);
            knex.destroy();
        });

    function sendKeywordInqueue(array)
    {
        var promises = [];
        for( var i in array)
        {
            var promise = sqs.sendMessage({
                MessageBody: JSON.stringify(array[i]),
                QueueUrl: sqsQueueUrl
            }).promise().catch(function(error) 
            { 
                console.error(error);
            });
            promises.push(promise);
        }

        console.log(promises);

        Promise.all(promises)
            .catch(function(error) 
            { 
                console.error(error);
            })
            .then(function() 
            {
                callback(null, "DONE");
                context.succeed('Il y a eu '+array.length+' nouveau keywords enregistré et qui va être scrapé');
                knex.destroy();
            });
    }

    function dataStoredInDb(firstIdSavedInDb, arrayWithKeywords) 
    {
        id = firstIdSavedInDb -1;
        return arrayWithKeywords.map(function (obj, i) {
            var rObj = {};
            rObj.id = id + i + 1;
            rObj.keywords = obj.keywords;
            return rObj;
        })
    }

    function returnArrayWithOnlyKeywords(resultDb)
    {
        var dataKeywords = [];

        for(var key in resultDb)
        {
            dataKeywords.push(resultDb[key].keywords);
        }

        return dataKeywords;
    }
};

Answer 1

如果有人回到这个问题，则需要等待Promise.all，即：

const res = await Promise.all([
    Do_Stuff(),
    Do_more_stuff()
    ])
    .then(() => callback(null,{
        'statusCode': 200,
        'headers' : {'Access-Control-Allow-Origin' : '*'},
        'body' : All Good)
      })
    .catch(() => callback('Something went wrong'))
  )

Answer 2

我们必须查看您实际的 lambda 处理程序，但您可能会在异步操作完成之前退出 lambda。您尝试过回调参数吗？

exports.handler = function(event, context, callback) {
    handleWhatever(context, callback);
};

然后你完成后，你可以打电话

callback(null, "DONE");