搜公众号
推荐 原创 视频 Java开发 开发工具 Python开发 Kotlin开发 Ruby开发 .NET开发 服务器运维 开放平台 架构师 大数据 云计算 人工智能 开发语言 其它开发 iOS开发 前端开发 JavaScript开发 Android开发 PHP开发 数据库
Lambda在线 > 有赞coder > Dubbo 压测插件的实现——基于 Gatling

Dubbo 压测插件的实现——基于 Gatling

有赞coder 2019-01-22
举报

文 | 聂风 on 测试


Dubbo 压测插件已开源,本文涉及代码详见 gatling-dubbo(点击阅读原文)

Gatling 是一个开源的基于 Scala、Akka、Netty 实现的高性能压测框架,较之其他基于线程实现的压测框架,Gatling 基于 AKKA Actor 模型实现,请求由事件驱动,在系统资源消耗上低于其他压测框架(如内存、连接池等),使得单台施压机可以模拟更多的用户。此外,Gatling 提供了一套简单高效的 DSL(领域特定语言)方便我们编排业务场景,同时也具备流量控制、压力控制的能力并提供了良好的压测报告,所以有赞选择在 Gatling 基础上扩展分布式能力,开发了自己的全链路压测引擎 MAXIM。全链路压测中我们主要模拟用户实际使用场景,使用 HTTP 接口作为压测入口,但有赞目前后端服务中 Dubbo 应用比重越来越高,如果可以知道 Dubbo 应用单机水位将对我们把控系统后端服务能力大有裨益。基于 Gatling 的优势和在有赞的使用基础,我们扩展 Gatling 开发了 gatling-dubbo 压测插件。

插件主要结构

实现 Dubbo 压测插件,需实现以下四部分内容:

  • Protocol 和 ProtocolBuild
    协议部分,这里主要定义 Dubbo 客户端相关内容,如协议、泛化调用、服务 URL、注册中心等内容,ProtocolBuild 则为 DSL 使用 Protocol 的辅助类

  • Action 和 ActionBuild
    执行部分,这里的作用是发起 Dubbo 请求,校验请求结果并记录日志以便后续生成压测报告。ActionBuild 则为 DSL 使用 Action 的辅助类

  • Check 和 CheckBuild
    检查部分,全链路压测中我们都使用 JsonPath检查请求结果,这里我们实现了一样的检查逻辑。CheckBuild 则为 DSL 使用 Check 的辅助类

  • DSL
    Dubbo 插件的领域特定语言,我们提供了一套简单易用的 API 方便编写 Duboo 压测脚本,风格上与原生 HTTP DSL 保持一致

Protocol

协议部分由 5 个属性组成,这些属性将在 Action 初始化 Dubbo 客户端时使用,分别是:

  • protocol
    协议,设置为 dubbo

  • generic
    泛化调用设置,Dubbo 压测插件使用泛化调用发起请求,所以这里设置为 true,有赞优化了泛化调用的性能,为了使用该特性,引入了一个新值 result_no_change(去掉优化前泛化调用的序列化开销以提升性能)

  • registryProtocol
    Dubbo 注册中心的协议,设置为 ETCD3

如果是测试 Dubbo 单机水位,则设置 url,注册中心设置为空;如果是测试 Dubbo 集群水位,则设置注册中心(目前支持 ETCD3),url 设置为空。由于目前注册中心只支持 ETCD3,插件在 Dubbo 集群上使用缺乏灵活性,所以我们又实现了客户端层面的负载均衡,如此便可抛开特定的注册中心来测试 Dubbo 集群水位。该特性目前正在内测中。

 
   
   
 
  1. object DubboProtocol {

  2.  val DubboProtocolKey = new ProtocolKey {

  3.    type Protocol = DubboProtocol

  4.    type Components = DubboComponents


  5.    def protocolClass: Class[io.gatling.core.protocol.Protocol] = classOf[DubboProtocol].asInstanceOf[Class[io.gatling.core.protocol.Protocol]]


  6.    def defaultProtocolValue(configuration: GatlingConfiguration): DubboProtocol = throw new IllegalStateException("Can't provide a default value for DubboProtocol")


  7.    def newComponents(system: ActorSystem, coreComponents: CoreComponents): DubboProtocol => DubboComponents = {

  8.      dubboProtocol => DubboComponents(dubboProtocol)

  9.    }

  10.  }

  11. }


  12. case class DubboProtocol(

  13.    protocol: String, //dubbo

  14.    generic:  String, //泛化调用?

  15.    url:      String, //use url or

  16.    registryProtocol: String,  //use registry

  17.    registryAddress:  String   //use registry

  18. ) extends Protocol {

  19.  type Components = DubboComponents

  20. }

为了方便 Action 中使用上面这些属性,我们将其装进了 Gatling 的 ProtocolComponents:

 
   
   
 
  1. case class DubboComponents(dubboProtocol: DubboProtocol) extends ProtocolComponents {

  2.  def onStart: Option[Session => Session] = None

  3.  def onExit: Option[Session => Unit] = None

  4. }

以上就是关于 Protocol 的定义。为了能在 DSL 中配置上述 Protocol,我们定义了 DubboProtocolBuilder,包含了 5 个方法分别设置 Protocol 的 protocol、generic、url、registryProtocol、registryAddress 5 个属性。

 
   
   
 
  1. object DubboProtocolBuilderBase {

  2.  def protocol(protocol: String) = DubboProtocolBuilderGenericStep(protocol)

  3. }


  4. case class DubboProtocolBuilderGenericStep(protocol: String) {

  5.  def generic(generic: String) = DubboProtocolBuilderUrlStep(protocol, generic)

  6. }


  7. case class DubboProtocolBuilderUrlStep(protocol: String, generic: String) {

  8.  def url(url: String) = DubboProtocolBuilderRegistryProtocolStep(protocol, generic, url)

  9. }


  10. case class DubboProtocolBuilderRegistryProtocolStep(protocol: String, generic: String, url: String) {

  11.  def registryProtocol(registryProtocol: String) = DubboProtocolBuilderRegistryAddressStep(protocol, generic, url, registryProtocol)

  12. }


  13. case class DubboProtocolBuilderRegistryAddressStep(protocol: String, generic: String, url: String, registryProtocol: String) {

  14.  def registryAddress(registryAddress: String) = DubboProtocolBuilder(protocol, generic, url, registryProtocol, registryAddress)

  15. }


  16. case class DubboProtocolBuilder(protocol: String, generic: String, url: String, registryProtocol: String, registryAddress: String) {

  17.  def build = DubboProtocol(

  18.    protocol = protocol,

  19.    generic = generic,

  20.    url = url,

  21.    registryProtocol = registryProtocol,

  22.    registryAddress = registryAddress

  23.  )

  24. }

Action

DubboAction 包含了 Duboo 请求逻辑、请求结果校验逻辑以及压力控制逻辑,需要扩展 ExitableAction 并实现 execute 方法。

DubboAction 类的域 argTypes、argValues 分别是泛化调用请求参数类型和请求参数值,需为 Expression[] 类型,这样当使用数据 Feeder 作为压测脚本参数输入时,可以使用类似 ${args_types}${args_values}这样的表达式从数据 Feeder 中解析对应字段的值。

execute 方法必须以异步方式执行 Dubbo 请求,这样前一个 Dubbo 请求执行后但还未等响应返回时虚拟用户就可以通过 AKKA Message 立即发起下一个请求,如此一个虚拟用户可以在很短的时间内构造大量请求。请求方式方面,相比于泛化调用,原生 API 调用需要客户端载入 Dubbo 服务相应的 API 包,但有时候却拿不到,此外,当被测 Dubbo 应用多了,客户端需要载入多个 API 包,所以出于使用上的便利性,Dubbo 压测插件使用泛化调用发起请求。

异步请求响应后会执行 onComplete 方法,校验请求结果,并根据校验结果记录请求成功或失败日志,压测报告就是使用这些日志统计计算的。

为了控制压测时的 RPS,则需要实现 throttle 逻辑。实践中发现,高并发情况下,泛化调用性能远不如原生 API 调用性能,且响应时间成倍增长(如此不能表征 Dubbo 应用的真正性能),导致 Dubbo 压测插件压力控制不准,解决办法是优化泛化调用性能,使之与原生 API 调用的性能相近,请参考dubbo 泛化调用性能优化。

 
   
   
 
  1. class DubboAction(

  2.    interface:        String,

  3.    method:           String,

  4.    argTypes:         Expression[Array[String]],

  5.    argValues:        Expression[Array[Object]],

  6.    genericService:   GenericService,

  7.    checks:           List[DubboCheck],

  8.    coreComponents:   CoreComponents,

  9.    throttled:        Boolean,

  10.    val objectMapper: ObjectMapper,

  11.    val next:         Action

  12. ) extends ExitableAction with NameGen {


  13.  override def statsEngine: StatsEngine = coreComponents.statsEngine


  14.  override def name: String = genName("dubboRequest")


  15.  override def execute(session: Session): Unit = recover(session) {

  16.    argTypes(session) flatMap { argTypesArray =>

  17.      argValues(session) map { argValuesArray =>

  18.        val startTime = System.currentTimeMillis()

  19.        val f = Future {

  20.          try {

  21.            genericService.$invoke(method, argTypes(session).get, argValues(session).get)

  22.          } finally {

  23.          }

  24.        }


  25.        f.onComplete {

  26.          case Success(result) =>

  27.            val endTime = System.currentTimeMillis()

  28.            val resultMap = result.asInstanceOf[JMap[String, Any]]

  29.            val resultJson = objectMapper.writeValueAsString(resultMap)

  30.            val (newSession, error) = Check.check(resultJson, session, checks)

  31.            error match {

  32.              case None =>

  33.                statsEngine.logResponse(session, interface + "." + method, ResponseTimings(startTime, endTime), Status("OK"), None, None)

  34.                throttle(newSession(session))

  35.              case Some(Failure(errorMessage)) =>

  36.                statsEngine.logResponse(session, interface + "." + method, ResponseTimings(startTime, endTime), Status("KO"), None, Some(errorMessage))

  37.                throttle(newSession(session).markAsFailed)

  38.            }

  39.          case FuFailure(e) =>

  40.            val endTime = System.currentTimeMillis()

  41.            statsEngine.logResponse(session, interface + "." + method, ResponseTimings(startTime, endTime), Status("KO"), None, Some(e.getMessage))

  42.            throttle(session.markAsFailed)

  43.        }

  44.      }

  45.    }

  46.  }


  47.  private def throttle(s: Session): Unit = {

  48.    if (throttled) {

  49.      coreComponents.throttler.throttle(s.scenario, () => next ! s)

  50.    } else {

  51.      next ! s

  52.    }

  53.  }

  54. }

DubboActionBuilder 则是获取 Protocol 属性并初始化 Dubbo 客户端:

 
   
   
 
  1. case class DubboActionBuilder(interface: String, method: String, argTypes: Expression[Array[String]], argValues: Expression[Array[Object]], checks: List[DubboCheck]) extends ActionBuilder {

  2.  private def components(protocolComponentsRegistry: ProtocolComponentsRegistry): DubboComponents =

  3.    protocolComponentsRegistry.components(DubboProtocol.DubboProtocolKey)


  4.  override def build(ctx: ScenarioContext, next: Action): Action = {

  5.    import ctx._

  6.    val protocol = components(protocolComponentsRegistry).dubboProtocol

  7.    //Dubbo客户端配置

  8.    val reference = new ReferenceConfig[GenericService]

  9.    val application = new ApplicationConfig

  10.    application.setName("gatling-dubbo")

  11.    reference.setApplication(application)

  12.    reference.setProtocol(protocol.protocol)

  13.    reference.setGeneric(protocol.generic)

  14.    if (protocol.url == "") {

  15.      val registry = new RegistryConfig

  16.      registry.setProtocol(protocol.registryProtocol)

  17.      registry.setAddress(protocol.registryAddress)

  18.      reference.setRegistry(registry)

  19.    } else {

  20.      reference.setUrl(protocol.url)

  21.    }

  22.    reference.setInterface(interface)

  23.    val cache = ReferenceConfigCache.getCache

  24.    val genericService = cache.get(reference)

  25.    val objectMapper: ObjectMapper = new ObjectMapper()

  26.    new DubboAction(interface, method, argTypes, argValues, genericService, checks, coreComponents, throttled, objectMapper, next)

  27.  }

  28. }

LambdaProcessBuilder 则提供了设置 Dubbo 泛化调用入参的 DSL 以及接下来要介绍的 Check 部分的 DSL:

 
   
   
 
  1. case class DubboProcessBuilder(interface: String, method: String, argTypes: Expression[Array[String]] = _ => Success(Array.empty[String]), argValues: Expression[Array[Object]] = _ => Success(Array.empty[Object]), checks: List[DubboCheck] = Nil) extends DubboCheckSupport {


  2.  def argTypes(argTypes: Expression[Array[String]]): DubboProcessBuilder = copy(argTypes = argTypes)


  3.  def argValues(argValues: Expression[Array[Object]]): DubboProcessBuilder = copy(argValues = argValues)


  4.  def check(dubboChecks: DubboCheck*): DubboProcessBuilder = copy(checks = checks ::: dubboChecks.toList)


  5.  def build(): ActionBuilder = DubboActionBuilder(interface, method, argTypes, argValues, checks)

  6. }

Check

全链路压测中,我们都使用 JsonPath校验 HTTP 请求结果,Dubbo 压测插件中,我们也实现了基于 JsonPath的校验。实现 Check,必须实现 Gatling check 中的 Extender 和 Preparer:

 
   
   
 
  1. package object dubbo {

  2.  type DubboCheck = Check[String]


  3.  val DubboStringExtender: Extender[DubboCheck, String] =

  4.    (check: DubboCheck) => check


  5.  val DubboStringPreparer: Preparer[String, String] =

  6.    (result: String) => Success(result)

  7. }

基于 JsonPath的校验逻辑:

 
   
   
 
  1. trait DubboJsonPathOfType {

  2.  self: DubboJsonPathCheckBuilder[String] =>


  3.  def ofType[X: JsonFilter](implicit extractorFactory: JsonPathExtractorFactory) = new DubboJsonPathCheckBuilder[X](path, jsonParsers)

  4. }


  5. object DubboJsonPathCheckBuilder {

  6.  val CharsParsingThreshold = 200 * 1000


  7.  def preparer(jsonParsers: JsonParsers): Preparer[String, Any] =

  8.    response => {

  9.      if (response.length() > CharsParsingThreshold || jsonParsers.preferJackson)

  10.        jsonParsers.safeParseJackson(response)

  11.      else

  12.        jsonParsers.safeParseBoon(response)

  13.    }


  14.  def jsonPath(path: Expression[String])(implicit extractorFactory: JsonPathExtractorFactory, jsonParsers: JsonParsers) =

  15.    new DubboJsonPathCheckBuilder[String](path, jsonParsers) with DubboJsonPathOfType

  16. }


  17. class DubboJsonPathCheckBuilder[X: JsonFilter](

  18.    private[check] val path:        Expression[String],

  19.    private[check] val jsonParsers: JsonParsers

  20. )(implicit extractorFactory: JsonPathExtractorFactory)

  21.  extends DefaultMultipleFindCheckBuilder[DubboCheck, String, Any, X](

  22.    DubboStringExtender,

  23.    DubboJsonPathCheckBuilder.preparer(jsonParsers)

  24.  ) {

  25.  import extractorFactory._


  26.  def findExtractor(occurrence: Int) = path.map(newSingleExtractor[X](_, occurrence))

  27.  def findAllExtractor = path.map(newMultipleExtractor[X])

  28.  def countExtractor = path.map(newCountExtractor)

  29. }

DubboCheckSupport 则提供了设置 jsonPath 表达式的 DSL:

 
   
   
 
  1. trait DubboCheckSupport {

  2.  def jsonPath(path: Expression[String])(implicit extractorFactory: JsonPathExtractorFactory, jsonParsers: JsonParsers) =

  3.    DubboJsonPathCheckBuilder.jsonPath(path)

  4. }

Dubbo 压测脚本中可以设置一个或多个 check 校验请求结果,使用 DSL check 方法

DSL

trait AwsDsl提供顶层 DSL。我们还定义了 dubboProtocolBuilder2DubboProtocol、dubboProcessBuilder2ActionBuilder 两个 Scala 隐式方法,以自动构造 DubboProtocol 和 ActionBuilder。

此外,泛化调用中使用的参数类型为 Java 类型,而我们的压测脚本使用 Scala 编写,所以这里需要做两种语言间的类型转换,所以我们定义了 transformJsonDubboData 方法。

 
   
   
 
  1. trait DubboDsl extends DubboCheckSupport {

  2.  val Dubbo = DubboProtocolBuilderBase


  3.  def dubbo(interface: String, method: String) = DubboProcessBuilder(interface, method)


  4.  implicit def dubboProtocolBuilder2DubboProtocol(builder: DubboProtocolBuilder): DubboProtocol = builder.build


  5.  implicit def dubboProcessBuilder2ActionBuilder(builder: DubboProcessBuilder): ActionBuilder = builder.build()


  6.  def transformJsonDubboData(argTypeName: String, argValueName: String, session: Session): Session = {

  7.    session.set(argTypeName, toArray(session(argTypeName).as[JList[String]]))

  8.      .set(argValueName, toArray(session(argValueName).as[JList[Any]]))

  9.  }


  10.  private def toArray[T:ClassTag](value: JList[T]): Array[T] = {

  11.    value.asScala.toArray

  12.  }

  13. }

 
   
   
 
  1. object Predef extends DubboDsl

Dubbo 压测脚本和数据 Feeder 示例

压测脚本示例:

 
   
   
 
  1. import io.gatling.core.Predef._

  2. import io.gatling.dubbo.Predef._


  3. import scala.concurrent.duration._


  4. class DubboTest extends Simulation {

  5.  val dubboConfig = Dubbo

  6.    .protocol("dubbo")

  7.    .generic("true")

  8.    //直连某台Dubbo机器,只单独压测一台机器的水位

  9.    //或设置注册中心,压测该Dubbo应用集群的水位,支持ETCD3注册中心

  10.    .registryProtocol("")

  11.    .registryAddress("")


  12.  val jsonFileFeeder = jsonFile("data.json").circular  //数据Feeder

  13.  val dubboScenario = scenario("load test dubbo")

  14.    .forever("repeated") {

  15.      feed(jsonFileFeeder)

  16.        .exec(session => transformJsonDubboData("args_types1", "args_values1", session))

  17.        .exec(dubbo("com.xxx.xxxService", "methodName")

  18.          .argTypes("${args_types1}")

  19.          .argValues("${args_values1}")

  20.          .check(jsonPath("$.code").is("200"))

  21.        )

  22.    }


  23.  setUp(

  24.    dubboScenario.inject(atOnceUsers(10))

  25.      .throttle(

  26.        reachRps(10) in (1 seconds),

  27.        holdFor(30 seconds))

  28.  ).protocols(dubboConfig)

  29. }

data.json 示例:

 
   
   
 
  1. [

  2.  {

  3.  "args_types1": ["com.xxx.xxxDTO"],

  4.  "args_values1": [{

  5.    "field1": "111",

  6.    "field2": "222",

  7.    "field3": "333"

  8.  }]

  9.  }

  10. ]

Dubbo 压测报告示例

招聘
有赞测试组在持续招人中,大量岗位空缺,只要你来,就能帮你点亮全栈开发技能树,有意向换工作的同学可以发简历到 sunjun@youzan.com


扩展阅读

1. 

2. 

3. 


-The End-

Vol.135







有赞技术团队

为 300 万商家,150 个行业,200 亿电商交易额

提供技术支持


微商城|零售|美业


技术博客:tech.youzan.com




The bigger the dream, 

the more important the team.

版权声明:本站内容全部来自于腾讯微信公众号,属第三方自助推荐收录。《Dubbo 压测插件的实现——基于 Gatling》的版权归原作者「有赞coder」所有,文章言论观点不代表Lambda在线的观点, Lambda在线不承担任何法律责任。如需删除可联系QQ:516101458

文章来源: 阅读原文

相关阅读

举报