鉴于所有调用都是异步的，您如何在lambda中构建顺序AWS服务调用？

Question

我有java背景，对Lambda所需的Javascript约定有点陌生。

我有一个lambda函数，它可以按照特定的顺序执行几个AWS任务，具体取决于前一个任务的结果。

考虑到每个任务都异步报告其结果，我想知道是否正确的方法可以确保它们都按正确的顺序发生，并且一个操作的结果可供下一个函数调用。

似乎我必须在前一个函数的回调中包含每个函数，但似乎这将进行某种深度嵌套，并想知道这是否是正确的方法。

例如，这些函数中的一个需要DynamoDB getItem，然后调用SNS以获取endpoint，然后调用SNS以发送消息，然后写入DynamoDB。

在lambda javascript中html" target="_blank">执行此操作的正确方法是什么，以解释所有异步性？

Answer 1

我不知道Lambda，但您应该研究节点异步库作为对异步函数进行排序的一种方式。

异步让我的生活变得更轻松，我的代码也更有序，没有你在问题中提到的深度嵌套问题。

典型的异步代码可能如下所示：

async.waterfall([
    function doTheFirstThing(callback) {
         db.somecollection.find({}).toArray(callback);
    },
    function useresult(dbFindResult, callback) {
         do some other stuff  (could be synch or async)
         etc etc etc
         callback(null);
],
function (err) {
    //this last function runs anytime any callback has an error, or if no error
    // then when the last function in the array above invokes callback.
    if (err) { sendForTheCodeDoctor(); }
});

看看上面链接中的异步doco。对于串行、并行、瀑布等有许多有用的函数。Async是主动维护的，看起来非常可靠。

祝你好运

Answer 2

简短回答：

使用Async/Await-并使用. Promise（）扩展名调用AWS服务（例如SNS）以告诉aws-sdk使用该服务函数的Promise-tify版本而不是基于回调的版本。

由于要按特定顺序执行它们，因此可以使用Async/Await，前提是从中调用它们的父函数本身是异步的。

例如：

let snsResult = await sns.publish({
    Message: snsPayload,
    MessageStructure: 'json',
    TargetArn: endPointArn
}, async function (err, data) {
    if (err) {
        console.log("SNS Push Failed:");
        console.log(err.stack);
        return;
    }
    console.log('SNS push suceeded: ' + data);
    return data;
}).promise();

重要的部分是。promise（）在最后。以下是有关以异步/基于promise的方式使用aws sdk的完整文档：https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/using-promises.html

为了运行另一个aws sdk任务，您将类似地添加wait和。该函数的promise（）扩展（假设可用）。

对于任何遇到此线程并实际希望将promise推送到一个数组并等待整个数组完成（不考虑先执行哪个promise）的人，我的结论如下：

let snsPromises = [] // declare array to hold promises
let snsResult = await sns.publish({
    Message: snsPayload,
    MessageStructure: 'json',
    TargetArn: endPointArn
}, async function (err, data) {
    if (err) {
        console.log("Search Push Failed:");
        console.log(err.stack);
        return;
    }
    console.log('Search push suceeded: ' + data);
    return data;
}).promise();

snsPromises.push(snsResult)
await Promise.all(snsPromises)

希望这能帮助那些像我一样通过谷歌偶然发现这一点的人！

Answer 3

我喜欢jonathanbaraldi的回答，但我认为如果你用promise来管理控制流会更好。Q库有一些方便的函数，如nbind，可以帮助将aws sdk之类的节点式回调API转换为promises。

因此，在本例中，我将发送一封电子邮件，然后当电子邮件响应返回时，我将发送第二封电子邮件。这就是所要求的，按顺序调用多个服务。我正在使用promises的then方法以一种垂直可读的方式来管理它。还可以使用catch来处理错误。我认为只要简单地嵌套回调函数，它的可读性就会更好。

var Q = require('q');
var AWS = require('aws-sdk');    
AWS.config.credentials = { "accessKeyId": "AAAA","secretAccessKey": "BBBB"};
AWS.config.region = 'us-east-1';

// Use a promised version of sendEmail
var ses = new AWS.SES({apiVersion: '2010-12-01'});
var sendEmail = Q.nbind(ses.sendEmail, ses);

exports.handler = function(event, context) {

    console.log(event.nome);
    console.log(event.email);
    console.log(event.mensagem);

    var nome = event.nome;
    var email = event.email;
    var mensagem = event.mensagem;

    var to = ['[e-mail]'];
    var from = '[e-mail]';

    // Send email
    mensagem = ""+nome+"||"+email+"||"+mensagem+"";

    console.log(mensagem);

    var params = { 
        Source: from, 
        Destination: { ToAddresses: to },
        Message: {
        Subject: {
            Data: 'Form contact our Site'
        },
        Body: {
            Text: {
                Data: mensagem,
            }
        }
    };

    // Here is the white-meat of the program right here.
    sendEmail(params)
        .then(sendAnotherEmail)
        .then(success)
        .catch(logErrors);

    function sendAnotherEmail(data) {
        console.log("FIRST EMAIL SENT="+data);

        // send a second one.
        return sendEmail(params);
    }

    function logErrors(err) {
        console.log("ERROR="+err, err.stack);
        context.done();
    }

    function success(data) {
        console.log("SECOND EMAIL SENT="+data);
        context.done();
    }
}