gRPC 请求低吞吐量然后出错

Question

我们注意到，使用 locust 时，我们的吞吐量比使用ghz工具低得多。 我们使用的是自定义 grpc 客户端，因此可能配置错误，但我们复制了示例并更改了生成的客户端。

使用ghz ，我们可以轻松达到 800 RPS (OKs)，而在开始报告超时之前我们几乎无法达到 100RPS (OKs)，并且故障率变为 100%。 我们有c5n.large实例作为工作人员 (4vCPU)，并将它们配置为每个节点启动 4 个处理，每个 vCPU 一个。 如果我在本地跑步，我会得到相同的特征，所以我认为它与蝗虫有关。

查看cloudwatch，我们可以清楚地看到网络日志中的ghz工具流量，而使用locust时，发生错误时，并没有将流量设置到LB的。

这可能有点抽象，但老实说，我很困惑，想知道其他人是否遇到过它，以及是否有人有解决方案。

**** 更新 *** 小注，但要获得相似的吞吐量，我必须有 120 名工人，而我的本地 16 核机器。 我知道，不是苹果对苹果，但仍然如此。

import json
from random import choice
import grpc
import protos.segments_pb2
import protos.segments_pb2_grpc
from client import client
from locust import events, User, task, run_single_user, constant, TaskSet, between
from locust.exception import LocustError
from locust.user.task import LOCUST_STATE_STOPPING
import gevent
import time
import grpc.experimental.gevent as grpc_gevent
import jwt
import time
import math
from locust import LoadTestShape

grpc_gevent.init_gevent()

def getMetadata():
    metadata = [('authorization', "aaaa")]
    return metadata

def credentials(context, callback):
    callback(getMetadata(), None)

def getCredentials():
    sslCred = grpc.ssl_channel_credentials()

    authcred = grpc.metadata_call_credentials(credentials)

    return grpc.composite_channel_credentials(sslCred, authcred)

class GrpcUser(User):
    #wait_time = between(2, 4)
    abstract = True

    stub_class = None

    def __init__(self, environment):
        super().__init__(environment)
        for attr_value, attr_name, in ((self.host, "host"), (self.stub_class, "stub_class")):
            if attr_value is None:
                raise LocustError(f"You must specify the {attr_name}.")
        self._channel = grpc.secure_channel(self.host, getCredentials())
        self._channel_closed = False
        stub = self.stub_class(self._channel)
        self.client = client.GrpcClient(environment, stub)

class SegmentsGrpcUser(GrpcUser):
    host = ""
    stub_class = protos.segments_pb2_grpc.MetadataStub

    @task
    def segmentWrite(self):
        if not self._channel_closed:
            meta_file = open("metadata.json")
            metadata = json.load(meta_file)
            data = choice(metadata)
            dataBytes = bytes(json.dumps(data), 'utf-8')
            self.client.Write(protos.segments_pb2.WriteRequest(ID=data['ID'], Metadata=dataBytes),timeout=10)
            meta_file.close()
        time.sleep(1)

class StepLoadShape(LoadTestShape):
    """
    A step load shape


    Keyword arguments:

        step_time -- Time between steps
        step_load -- User increase amount at each step
        spawn_rate -- Users to stop/start per second at every step
        time_limit -- Time limit in seconds

    """

    step_time = 10
    step_load = 50
    spawn_rate = 25
    time_limit = 600

    def tick(self):
        run_time = self.get_run_time()

        if run_time > self.time_limit:
            return None

        current_step = math.floor(run_time / self.step_time) + 1
        return (current_step * self.step_load, self.spawn_rate)