k6.io-ով performance թեստավորումը Scala նախագծերում առանց դժվարության՝ Scala.js-ի միջոցով
Այս հոդվածում դիտարկում ենք k6 թեստերը Scala-ով Scala.js-ի միջոցով գրելը և այն, թե ինչ է դա տալիս՝ կոմպիլյացիայի ժամանակի երաշխիքներ, ֆունկցիոնալ կոմպոզիցիա և ուղղակի ինտեգրացիա։
Այսօրվա համակարգերը հազվադեպ են կոտրվում մեկ սխալի պատճառով։ Շատ ավելի հաճախ դրանք վատանում են իրական աշխարհի ճնշման տակ. տրաֆիկի հանկարծակի պոռթկումներ, սերվիսների միջև շատախոս զանգեր, դանդաղ արտահոսքեր, որոնք երևում են միայն բեռի տակ մի քանի ժամ անց։ Performance-ի խնդիրները այժմ անընդհատ հայտնվում են արտադրական միջավայրում, այլ ոչ թե հատուկ թեստավորման փուլում։ Ամպային միջավայրերը և SRE-կենտրոն observability-ն բեռի վալիդացիան դուրս են բերել վերահսկվող լաբորատորիայից և տեղափոխել առաքման pipeline-ի մեջ։ Եթե ապավինում եք auto-scaling-ին և dashboard-ներին, խնդիրները գտնում եք միայն այն ժամանակ, երբ դրանք արդեն վնասում են օգտատերերին արտադրական միջավայրում։
K6-ը լուծում է այս խնդիրներից մի քանիսը՝ performance թեստերը դարձնելով կոդ. տարբերակավորված, ավտոմատացված և ուղղակիորեն միացված CI-ին։ Սակայն նրա սկրիպտավորման մոդելը միայն JavaScript է, ինչը չի հարմարում Scala-ով բաշխված բեքենդներ կառուցող թիմերին։ Դուք հրաժարվում եք տիպերի անվտանգությունից, FP patterns* և domain տրամաբանությունը և ընդհանուր գրադարանները վերօգտագործելու հնարավորությունից, որոնք սահմանում են, թե ինչպես է վարվում համակարգը։
Այս հոդվածը ուսումնասիրում է այլ ճանապարհ. k6 թեստեր գրել Scala-ով Scala.js-ի միջոցով։ Runtime մոդելը մնում է նույնը, և k6 էկոհամակարգը նույնպես։ Այն, ինչ շահում ենք, կոմպիլյացիայի ժամանակի երաշխիքներն են, ֆունկցիոնալ կոմպոզիցիան և Scala-ի վրա հիմնված նախագծերի մեջ ուղղակի ինտեգրացիան։ Performance թեստավորումը դառնում է ծրագրային ճարտարագիտության առաջին կարգի մաս, այլ ոչ թե հանելուկի վերջին կտոր, որը հաճախ մշակվում է առանձին թիմի կողմից։ Մենք կարող ենք կրճատել հետադարձ կապի ցիկլերը, ինչը կարող է լրացնել DevOps-ի և SRE-ի առաջ քաշած լայնորեն տարածված «shift-right» մոտեցումը։
Նախապատմություն
k6-ը այժմ performance թեստեր կառուցելու ամենահայտնի գործիքներից է։ Մշակողները և QA ինժեներները գնահատում են, թե որքան պարզ, ընթեռնելի և ինտեգրվող է այն։
Փաստաթղթերի խոսքերով.
Grafana k6-ը ընդլայնելի, բաց կոդով բեռնվածքային թեստավորման գործիք է, որը կառուցված է մշակողներին նկատի ունենալով։ k6-ով կարող եք կանխարգելել performance-ի խնդիրները և նախաձեռնողականորեն բարելավել հուսալիությունը։
k6-ը թեթև կոմպիլացված երկուական ֆայլ է, գրված GO-ով, որը ներդնում է Goja JavaScript մեկնաբանիչը։ Այս ձևավորումը գիտակցված փոխզիջում է. այն օգտվում է JavaScript էկոհամակարգի հասունությունից և ծանոթությունից՝ միաժամանակ պահպանելով Go լեզվի ռեսուրսների ցածր սպառումը և արդյունավետությունը։ Հետևաբար, թեստային սկրիպտները գրվում են JavaScript-ով. խելամիտ ընտրություն, քանի որ և՛ մշակողները, և՛ QA ինժեներները լավ գիտեն լեզուն։
Թեստերը կարող են աշխատել տեղականորեն կամ ամպային միջավայրում շատ քիչ boilerplate-ով։ K6.io-ն լավ է աշխատում Grafana-ի հետ, ինչը թույլ է տալիս թեստերի գործարկումների գրեթե իրական ժամանակի մոնիթորինգ։ Նրա extension API-ը թույլ է տալիս օգտագործել համայնքի առկա ընդլայնումները կամ գրել սեփականը՝ օրինակ՝ հատուկ ցանցային արձանագրություններ աջակցելու համար։
Ինչո՞ւ նայել JavaScript-ից այն կողմ
JavaScript-ը կարող է լռելյայն լինել շատ ինժեներների, հատկապես ծրագրային որակի մասնագետների համար, բայց արժանի են ուշադրության նաև այլ տարբերակներ։ Scala-ն, թեև հայտնի է իր բարդությամբ, տրամադրում է ուժեղ interoperability և հարուստ հնարավորությունների հավաքածու, որը կարող է արդարանալ performance թեստավորման մեջ։ Այն թիմերը, որոնց կոդային բազան արդեն Scala-ով է, շատ բան կարող են շահել։
Այստեղ մենք կնշենք և՛ ուժեղ, և՛ թույլ կողմերը, որ Scala-ն բերում է, որպեսզի կարողանաք դատել՝ արդյոք այն հարմար է ձեր կիրառման դեպքին։ Մենք նաև կցուցադրենք, թե ինչպես ինտեգրել այն մի քանի Scala build գործիքներով կառուցված նախագծերի հետ՝ sbt, mill և Gradle։
Սակայն դրանից առաջ մի քանի խոսք Scala.js-ի մասին, որն էլ հնարավոր է դարձնում այս ամենը։
Scala.js-ը որպես կամուրջ դեպի k6
Scala.js-ով կարող ենք գրել Scala հավելվածներ, որոնք կոմպիլացվում են JavaScript-ի և աշխատում ցանկացած ժամանակակից բրաուզերում կամ JavaScript runtime-ում։ Այսպիսով, կարող եք օգտագործել Scala-ի ստատիկ տիպավորումը և առաջադեմ հնարավորությունները՝ ֆունկցիոնալ ծրագրավորման կոնստրուկցիաներ, հզոր collection-ներ և արտահայտիչ շարահյուսություն՝ միաժամանակ թիրախավորելով JavaScript էկոհամակարգը։
Այս կերպ Scala.js-ը կարող է բարձրացնել կոդի որակը և սպասարկելիությունը՝ շնորհիվ ավելի ուժեղ տիպերի անվտանգության և կոմպիլյատորի ավելի լավ երաշխիքների։ Այն նաև թույլ է տալիս վերօգտագործել առկա Scala գրադարանները (որոշակի չափով) և սահուն ինտեգրվել JavaScript գրադարանների հսկայական էկոհամակարգի հետ։ Սա այն դարձնում է հզոր օղակ JVM աշխարհի և JavaScript runtime-ի միջև։
Այս հիմքերը դնելուց հետո կարող ենք անցնել Scala.js-ով k6 գրադարանի facade-ի կառուցմանը և սկսել նախատիպավորել լուծումը, որին ձգտում ենք։
Ճամփորդություն. գաղափարից իրականացում
Scala.js-ը k6-ի հետ օգտագործելը սկսվեց պարզ դիտարկումից. k6-ն առաջարկում է նրբագեղ եղանակ performance թեստեր գրելու JavaScript-ով, բայց այն թվում էր անջատված արդեն Scala-ով գրված նախագծերից։ Մենք ուզում էինք շարունակել օգտագործել Scala-ի տիպային համակարգը և գործիքակազմը՝ միաժամանակ օգտվելով k6-ի ճկունությունից և էկոհամակարգից։
Ստուգելու համար, թե արդյոք դա իրագործելի է, Scala CLI-ով կառուցեցինք պարզ scala-js նախագիծ.
//> using scala "3.5.0"
//> using platform scala-js
package example
import scala.scalajs.js
import scala.scalajs.js.annotation.*
@js.native
object k6 extends js.Object {
def check(response: Response, checks: js.Dictionary[Boolean]): Boolean = js.native
def sleep(response: Int): Unit = sjs.native
}
@js.native
object http extends js.Object {
def get(url: String): Response = js.native
}
@js.native
trait Response extends js.Object {
def body: String = js.native
def status: Int = js.native
}
@JSExportTopLevel(JSImport.Default)
object K6ScalaExample {
@JSExport
def main(): Unit = {
val response = Http.get("https://quickpizza.grafana.com/")
}
}
Երբ ունեցանք ապացույց, որ մոտեցումը աշխատում է, կառուցեցինք k6 Grafana facade ScalaJS-ով, ինչը գործերը շատ պարզեցնում է.
//> using scala "3.5.0"
//> using platform scala-js
//> using dep "org.scala.js::k6-scala::0.0.1-SNAPSHOT"
package example
import scala.scalajs.js
import scala.scalajs.js.annotation.*
import org.scala.js.k6.http.Http
@JSExportTopLevel(JSImport.Default)
object K6ScalaExample {
@JSExport
def main(): Unit = {
val response = Http.get("https://quickpizza.grafana.com/")
}
}
Ինտեգրացիա build գործիքների հետ
Սա լավ տեսք ունի. բավականին կոկիկ իրականացում։ Ինքնուրույն թեստերի համար այն որոշ դեպքերում կարող է նույնիսկ բավարար լինել, բայց, ինչպես նախկինում ասացինք, իրական օգուտը գալիս է այն առկա նախագծերի հետ ինտեգրելուց։ Scala աշխարհում երեք հիմնական build գործիք կա՝ sbt, mill և Gradle։ Դրանցից յուրաքանչյուրը պահանջում է, որ տեղադրված լինի k6 Grafana-ն։
Հաստատելու համար, որ դա հնարավոր է, մենք կարգավորեցինք պարզ նախագիծ ճիշտ գործիքակազմով։ SBT-ի համար գրեցինք պարզ task.
lazy val root = Project("root", file("."))
.enablePlugins(ScalaJSPlugin)
.settings(
scalaVersion := "3.5.0",
publish / skip := true,
scalaJSLinkerConfig ~= {
_.withModuleSplitStyle(ModuleSplitStyle.FewestModules).withModuleKind(ModuleKind.ESModule)
},
runK6example := {
val jsTargetDir = (Compile / fullOptJS / crossTarget).value
val name = (Compile / fullOptJS / moduleName).value
val jsOutput = jsTargetDir / s"${name}-fastopt.js"
val log = streams.value.log
log.info(s"Using JS output: ${jsOutput.getAbsolutePath()}")
log.info(s"Running k6 test...")
val exitCode = Process(Seq("k6", "run", jsOutput.getAbsolutePath)).!
if (exitCode != 0) {
log.error("k6 failed!")
}
}
)
Նույն կերպ ավելացրինք հրաման mill-ի համար.
import mill._
import mill.api.Loose
import mill.scalalib._
import mill.scalajslib._
import mill.scalajslib.api._
val projectScalaVersion = "3.5.0"
object helloworld extends ScalaJSModule {
override def scalaVersion = projectScalaVersion
override def scalaJSVersion = "1.18.1"
override def ivyDeps: Target[Loose.Agg[Dep]] = super.ivyDeps() ++ Agg(
ivy"org.scalajs::k6-scala::0.0.1-SNAPSHOT".withDottyCompat(projectScalaVersion)
)
override def moduleKind = ModuleKind.ESModule
override def moduleSplitStyle = ModuleSplitStyle.FewestModules
override def sources = T.sources {
Seq(millSourcePath / "src").map(PathRef(_))
}
def runK6test() = T.command {
val jsFilePath: os.Path = fastLinkJS().dest.path / "main.js"
println(s"Using JS output: $jsFilePath")
val exitCode = os.proc("k6", "run", jsFilePath).call(stdout = os.Inherit, stderr = os.Inherit).exitCode
if (exitCode != 0) {
throw new Exception("k6 failed!")
}
}
}
Performance և մետրիկաներ
Աշխատող լուծումն ու build գործիքների ինտեգրացիաները պատրաստ ունենալով՝ ուզեցինք չափել, թե որքան լրացուցիչ ժամանակ կարող է արժենալ «սովորական» JavaScript-ի համեմատ։ Դրա համար օգտագործեցինք hyperfine՝ շատ պարզ շարահյուսությամբ գործիք.
hyperfine -r 100 -p 'rm -rf .scala-build/ example.js example.js.map' 'scala-cli --power package example.scala --js --js-emit-source-maps --js-module-kind esmodule -f --js-no-opt'
hyperfine -r 100 'k6 run example.js'
hyperfine -r 100 'k6 run pure.js'
hyperfine -r 100 -p 'mill clean' 'mill helloworld.fastOpt'
hyperfine -r 100 -p 'sbt clean' 'sbt fastOptJS'
hyperfine -r 100 -p './gradlew clean' './gradlew link'
hyperfine -r 100 'sbt runK6test'
hyperfine -r 100 'mill runK6test'
hyperfine -r 100 './gradlew runK6test'
Ենթադրություններ.
- Կոմպիլյացիայի ժամանակը և կատարման ժամանակը չափվել են առանձին։
- Կոմպիլյացիան սկսվում է մաքուր workspace-ից,
- Սկրիպտը փոփոխվել է 100 իտերացիա կատարելու համար՝ առանց որևէ իրական հարցում ուղարկելու։
- Ցուցադրված է միայն 100 կրկնության միջինը։
| տեխնոլոգիական ստեկ | կոմպիլյացիայի ժամանակ | կատարման ժամանակ |
|---|---|---|
| k6.io native | N/A | 358.5 ms |
| scala-js scala-cli-ով | 2.895 s | 467.0 ms |
| scala-js sbt-ով | 15.214 s | 8.735 s |
| scala-js mill-ով | 7.402 s | 752.1 ms |
| scala-js gradle-ով | 10.277 s | 4.313 s |
Թվերը ցույց են տալիս, որ նույնիսկ մաքուր workspace-ի դեպքում կոմպիլյացիան որոշակի ավելացուցիչ ծախս է ավելացնում թեստի ընդհանուր կատարման ժամանակի համեմատ։ Այս օրինակը շատ պարզ է, և իրական դեպքերում կոմպիլյացիան կարող է ավելի երկար տևել։ Մյուս կողմից, ժամանակի մեծ մասը կօգտագործվի ինկրեմենտալ կոմպիլյացիա, որը կարող է այս ավելացուցիչ ծախսը զգալիորեն կրճատել։
Կատարման ժամանակը նույնպես տարբերվում է։ Սա կարող է գալ Scala.js տարբերակի գեներացրած boilerplate կոդից և այն բանից, թե ինչպես է դա ազդում k6-ի մեկնաբանման արտադրողականության վրա։ Build գործիքների միջոցով աշխատեցնելը ավելացնում է ավելի շատ ավելացուցիչ ծախս։ Այնուամենայնիվ, քանի որ բեռնվածքային թեստերը սովորաբար աշխատում են րոպեներ, այլ ոչ թե վայրկյաններ, այս ավելացուցիչ ծախսը մեծ նշանակություն չպետք է ունենա։
k6 թեստերը Scala.js-ով գրելու դրական և բացասական կողմերը
Performance չափումները հստակ պատկեր են տալիս runtime-ի ավելացուցիչ ծախսի մասին։ Սակայն կատարման ժամանակը միայն գործոններից մեկն է, որոնք որոշում են՝ արդյոք Scala.js-ը հարմար է k6 թեստերի համար։ Եկեք մի քայլ հետ գնանք և դիտարկենք դրական և բացասական կողմերի ավելի լայն ցանկը։
k6 թեստերը Scala.js-ով գրելու դրական կողմերը
- Տիպերի անվտանգություն և IDE աջակցություն
- Ինտեգրացիա Scala-ի (և հավանաբար Java-ի) վրա հիմնված նախագծերի հետ
- Domain տրամաբանությունը վերօգտագործելու հնարավորություն
- Ավելի պարզ սպասարկում այն թիմերի համար, որոնք արդեն օգտագործում են Scala։
k6 թեստերը Scala.js-ով գրելու բացասական կողմերը
- Grafana k6.io-ն չունի բնիկ աջակցություն
- Լրացուցիչ կոմպիլյացիայի և կատարման ժամանակ
- Թեստերի ձախողումները հնարավոր չէ հետևել մինչև իրական թեստերը
- Ավելի փոքր համայնք և էկոհամակարգ
- Scala.js-ի սովորելու կորագիծ (եթե նախկինում չեք օգտագործել)
- Թեստերը հնարավոր չէ վրիպազերծել, թեև սա ընդհանրապես վերաբերում է Grafana k6.io-ին։
Ամփոփում
Անկասկած, JavaScript-ը k6-ի համար գնալու լեզուն է։ Այն բնիկ runtime-ն է, լայնորեն օգտագործվող և բացառիկ լավ փաստաթղթավորված։ Թիմերի մեծ մասի համար, հատկապես նրանց, որոնք իրենց առաջին քայլերն են անում performance թեստավորման մեջ, JavaScript-ը արդյունքին հասնելու ամենաարագ ճանապարհն է՝ նվազագույն կարգավորմամբ։
Ուրեմն ե՞րբ է Scala.js-ը արժե։
Ինչպես նախկինում նշվեց, Scala-ն գրավիչ ընտրություն է դառնում, երբ արդեն աշխատում եք Scala էկոհամակարգում, հատկապես խոշոր, տիպային անվտանգ կոդային բազաներում, որտեղ performance թեստերը պետք է սերտորեն համահունչ մնան առկա մոդելներին կամ տրամաբանությանը։
Դրանից բացի, Scala.js-ը կարող է լավ հարմար լինել նաև ձեզ, եթե՝
- Հոգ եք տանում տիպերի անվտանգության մասին՝ խնդիրները վաղ նկատելու և թեստերն ավելի հուսալի դարձնելու համար
- Նախընտրում եք ֆունկցիոնալ ծրագրավորման ոճ՝ թեստերը և դրանց տրամաբանությունը կազմելու համար
- Ցանկանում եք domain տրամաբանությունը կամ տվյալների մոդելները ուղղակիորեն վերօգտագործել performance թեստերում
Այնուամենայնիվ, ներկայիս սահմանափակումները պետք է ընդունել. մոտեցումը դեռ վաղ փուլում է։ Այն խոստումնալից է թվում, բայց լիովին արտադրական պատրաստության համար պահանջում է ավելի շատ աշխատանք՝ API-ի լրիվ ծածկույթ, պատշաճ փաթեթավորում և հրապարակում, ավելի լավ գործիքակազմ և սահուն runtime ինտեգրացիա։
Հղումներ և ռեսուրսներ
** JavaScript-ն առաջարկում է մի քանի ֆունկցիոնալ պրիմիտիվ, բայց առանց ստատիկ տիպերի դրանք մնում են պայմանավորվածություններ, այլ ոչ թե երաշխիքներ։*