如何达到AWS Lambda并发执行限制？-电脑我帮您

如何达到AWS Lambda并发执行限制？

UPDATE

下面的原始测试代码基本上是正确的，但在NodeJS中，根据@ Michael-sqlbot提供的SDK link，各种AWS服务的设置应该有所不同

// manager
const AWS = require("aws-sdk")
const https = require('https');
const agent = new https.Agent({
    maxSockets: 498 // workers hit this level; expect plus 1 for the manager instance
});
const lambda = new AWS.Lambda({
    apiVersion: '2015-03-31',
    region: 'us-east-2', // Initial concurrency burst limit = 500
    httpOptions: {   // <--- replace the default of 50 (https) by
        agent: agent // <--- plugging the modified Agent into the service
    }
})
// NOW begin the manager handler code

在计划新服务时，我正在做一些初步的压力测试。在阅读了每个帐户的the 1,000 concurrent execution limit和initial burst rate（在us-east-2中为500）之后，我期待立即实现至少500次爆发并发执行。 CloudWatch的Lambda指标的屏幕截图显示了其他情况。无论我尝试什么参数混合，我都无法通过51次并发执行。这是测试代码：

// worker
exports.handler = async (event) => {
    // declare sleep promise
    const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

    // return after one second
    let nStart = new Date().getTime()
    await sleep(1000)
    return new Date().getTime() - nStart; // report the exact ms the sleep actually took
};

// manager
exports.handler = async(event) => {
    const invokeWorker = async() => {
        try {
            let lambda = new AWS.Lambda() // NO! DO NOT DO THIS, SEE UPDATE ABOVE
            var params = {
                FunctionName: "worker-function",
                InvocationType: "RequestResponse",
                LogType: "None"
            };
            return await lambda.invoke(params).promise()

        }
        catch (error) {
            console.log(error)
        }
    };

    try {
        let nStart = new Date().getTime()
        let aPromises = []

        // invoke workers
        for (var i = 1; i <= 3000; i++) {
            aPromises.push(invokeWorker())
        }

        // record time to complete spawning
        let nSpawnMs = new Date().getTime() - nStart

        // wait for the workers to ALL return
        let aResponses = await Promise.all(aPromises)

        // sum all the actual sleep times
        const reducer = (accumulator, response) => { return accumulator + parseInt(response.Payload) };
        let nTotalWorkMs = aResponses.reduce(reducer, 0)

        // show me
        let nTotalET = new Date().getTime() - nStart
        return {
            jobsCount: aResponses.length,
            spawnCompletionMs: nSpawnMs,
            spawnCompletionPct: `${Math.floor(nSpawnMs / nTotalET * 10000) / 100}%`,
            totalElapsedMs: nTotalET,
            totalWorkMs: nTotalWorkMs,
            parallelRatio: Math.floor(nTotalET / nTotalWorkMs * 1000) / 1000
        }
    }

    catch (error) {
        console.log(error)
    }
};

Response:
{
  "jobsCount": 3000,
  "spawnCompletionMs": 1879,
  "spawnCompletionPct": "2.91%",
  "totalElapsedMs": 64546,
  "totalWorkMs": 3004205,
  "parallelRatio": 0.021
}

Request ID:
"43f31584-238e-4af9-9c5d-95ccab22ae84"

我是否达到了我未提及的不同限制？我的测试代码有缺陷吗？我试图在这里达到3000名工人的限制，但没有遇到限制，我想这是由于异步调用重试行为。

编辑：Lambda上没有涉及VPC;选择输入中的设置为“无VPC”。

编辑：在修复之前和之后显示Cloudwatch

回答如下：

有许多潜在的嫌疑人，特别是由于你从Lambda调用Lambda这一事实，但你一直看到50的并发性 - 一个看似任意的限制（以及一个可疑的数字） - 让我想起有一个反对-footgun潜伏在JavaScript SDK中：

在Node.js中，您可以设置每个源的最大连接数。如果设置了maxSockets，则低级HTTP客户端会将请求排队，并在它们可用时将它们分配给套接字。

当然，“origin”意味着scheme + hostname的任何独特组合，在这种情况下，为了调用endpoint方法Invoke，SDK连接到us-east-2中的lambda服务https://lambda.us-east-2.amazonaws。

这使您可以一次设置对给定源的并发请求数的上限。降低此值可以减少收到的限制或超时错误的数量。但是，它也可以增加内存使用量，因为请求会排队，直到套接字可用。

...

使用https的默认值时，SDK会从maxSockets获取globalAgent值。如果未定义maxSockets值或Infinity，则SDK假定maxSockets值为50。

https://docs.aws.amazon/sdk-for-javascript/v2/developer-guide/node-configuring-maxsockets.html