AWS Lambda：异步调用外部处理程序（初始化部分，调用 lambda）

Question

我想通过以下代码调用 lambda 处理程序外部的异步函数：

var client;
(async () => {
    var result =  await initSecrets("MyWebApi");
    var secret = JSON.parse(result.Payload);
    client= new MyWebApiClient(secret.API_KEY, secret.API_SECRET); 
});

async function initSecrets(secretName) {
    var input = {
    "secretName" : secretName
    };
    var result = await lambda.invoke({
       FunctionName: 'getSecrets',
       InvocationType: "RequestResponse",
       Payload: JSON.stringify(input)
    }).promise();
    return result;
}

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

    var myReq = await client('Request');
    console.log(myReq);
};

'client' 没有初始化。如果在处理程序中执行，相同的代码将完美运行。 initSecrets 包含 getSecrets() 的 lambda 调用，它调用 AWS SecretsManager 有谁知道如何在处理程序之外正确调用异步函数以进行初始化？

非常感谢您的支持。

Answer 1

client 在初始化之前被调用；在 async 函数完成之前，client var 正在 "exported"（并被调用）。当您调用 await client() 时，客户端仍将是 undefined.

编辑，试试这样的东西

var client = async which => {
    var result =  await initSecrets("MyWebApi");
    var secret = JSON.parse(result.Payload);
    let api = new MyWebApiClient(secret.API_KEY, secret.API_SECRET); 
    return api(which) // assuming api class is returning a promise
}

async function initSecrets(secretName) {
    var input = {
    "secretName" : secretName
    };
    var result = await lambda.invoke({
       FunctionName: 'getSecrets',
       InvocationType: "RequestResponse",
       Payload: JSON.stringify(input)
    }).promise();
    return result;
}

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

    var myReq = await client('Request');
    console.log(myReq);
};

Answer 2

我运行遇到了一个类似的问题，试图让 next-js 与 aws-serverless-express 一起工作。

我通过以下操作修复了它（使用打字稿，所以忽略 :any type 位）

const appModule = require('./App');
let server: any = undefined;

appModule.then((expressApp: any) => {
  server = createServer(expressApp, null, binaryMimeTypes);
});

function waitForServer(event: any, context: any){
  setImmediate(() => {
    if(!server){
      waitForServer(event, context);
    }else{
      proxy(server, event, context);
    }
  });
}

exports.handler = (event: any, context: any) => {
  if(server){
    proxy(server, event, context);
  }else{
    waitForServer(event, context);
  }
}

所以你的代码可能类似于

var client = undefined;

initSecrets("MyWebApi").then(result => {
    var secret = JSON.parse(result.Payload);
    client= new MyWebApiClient(secret.API_KEY, secret.API_SECRET)
})

function waitForClient(){
  setImmediate(() => {
    if(!client ){
      waitForClient();
    }else{
      client('Request')
    }
  });
}

exports.handler = async function (event, context) {
  if(client){
    client('Request')
  }else{
    waitForClient(event, context);
  }
};

Answer 3

这也可以通过 async/await give Node v8+

来解决

您可以像这样在模块中加载您的配置...

const fetch = require('node-fetch');

module.exports = async () => {

  const config = await fetch('https://cdn.jsdelivr.net/gh/GEOLYTIX/public/z2.json');

  return await config.json();

}

然后通过要求/执行配置模块在处理程序外声明一个_config。您的处理程序必须是异步函数。 _config 首先是一个承诺，您必须 await 才能解析为配置对象。

const _config = require('./config')();

module.exports = async (req, res) => {

  const config = await _config;

  res.send(config);

}

AWS Lambda：异步调用外部处理程序（初始化部分，调用 lambda）

AWS Lambda: Async Calls outside handler (initialization section, invoke lambda)

asynchronous

initialization

async-await

aws-lambda

aws-secrets-manager