Գնահատել նախագիծը
← Բոլոր հրապարակումները

Ինչպես չեղարկել HTTP հարցումները JVM-ում

Այս հոդվածում դիտարկում ենք լքված HTTP զանգերի առաջացրած խնդիրները և վերանայում, թե JVM-ի HTTP կլիենտները ինչպես են թույլ տալիս չեղարկել ընթացքի մեջ գտնվող հարցումները, ինչը կարող է խնայել ռեսուրսներ։

9 րոպե
ScalaJavaHTTPԱսինխրոնJVM

HTTP-ը հավելվածները արտաքին աշխարհին հասանելի դարձնելու և համակարգի ներսում միկրոսերվիսների միջև հաղորդակցության հիմնական միջոցներից է։ Վաղ թե ուշ գրեթե յուրաքանչյուր բեքենդ սերվիս ուղարկում է HTTP հարցում։

Սակայն երբեմն HTTP զանգի արդյունքը մեզ համար դադարում է կարևոր լինել։ Դրա համար կարող են լինել մի քանի պատճառներ, օրինակ՝

  • կարող ենք զուգահեռ ուղարկել մի քանի HTTP հարցում և շարունակել մշակել միայն առաջինը պատասխանողի արդյունքը (race)
  • ներքևի (downstream) HTTP հարցումը կարող է չափազանց երկար տևել, ուստի վերև (upstream) վերադարձվում է timeout պատասխան, կամ դրա փոխարեն օգտագործվում է լռելյայն արժեք (քեշավորված կամ հաշվարկված)

Մեզ այլևս չհետաքրքրող HTTP զանգերը մշակելու սովորական եղանակը դրանք պարզապես լքելն է։ Դրանք ավարտվում են, բայց ոչ ոք չի օգտագործում պատասխանը։ Լքվելուց առաջ այդպիսի պատասխանը կարող է նույնիսկ ամբողջությամբ բեռնվել հիշողության մեջ և վերլուծվել, օրինակ՝ JSON-ի – ինչը և՛ հիշողության, և՛ CPU-ի վատնում է։ Կա՞ ավելի լավ մոտեցում։

Պարզվում է՝ սովորաբար կա։ Մեր ուսումնասիրած JVM HTTP կլիենտների մեծ մասը թույլ է տալիս չեղարկել ընթացքի մեջ գտնվող HTTP հարցումը։ Տեսնենք, թե ինչպես է դա աշխատում։

Ի՞նչ է նշանակում չեղարկել HTTP հարցումը

HTTP-ի կառուցվածքի պատճառով, երբ հարցումն արդեն ուղարկվել է, սովորաբար ոչինչ չենք կարող անել սերվերի կողմից դրա մշակումը կանգնեցնելու համար։ Ուստի՝ հաշվի առնելով հարցման հնարավոր կողմնակի ազդեցությունները սերվերի վրա (օրինակ՝ եթե այն POST է), պետք է ենթադրենք, որ հարցումը մշակվել է ամբողջությամբ։

Ուրեմն ի՞նչ օգուտ ունի այն չեղարկելը։ Բացի հարցումը սերվերի կողմից մշակվելուց, կա նաև պատասխանը կլիենտին հետ ուղարկելու քայլը, որն ամենակարևորն է, երբ պատասխանը ոչ աննշան չափի է։ Բացի այդ, ինչպես նշվել է վերևում, կլիենտը կարող է պատասխանը հետագայում վերլուծել, և այդ աշխատանքը պետք է բաց թողնվի, եթե արդյունքը պատրաստվում են դեն նետել։

Այսպիսով, երբ չեղարկում ենք ընթացքի մեջ գտնվող HTTP հարցումը, նպատակն է խուսափել պատասխանի փոխանցումից, ինչպես նաև դրա ցանկացած վերլուծությունից կամ կլիենտի հիշողության մեջ բեռնումից։

Մեր թեստը

Մեր թեստը պարզ էր՝ մեկ endpoint և մեկ հարցում։ Երբ սերվերը ստանում է հարցումը, սպասում է 2 վայրկյան և ապա վերադարձնում 100MB պատասխան։ Կլիենտն ուղարկում է հարցումը, բայց չեղարկում է այն 1 վայրկյան անց (մինչ այդ ոչ մի պատասխանի տվյալ չպետք է ուղարկված լինի)։ «Չեղարկել» բառի ճշգրիտ իմաստը կախված է օգտագործվող կոնկրետ կլիենտի իրականացումից։

Մենք ստուգեցինք այս կլիենտները՝ async-http-client, Java-ի ներկառուցված HttpClient, OkHttp և http4s։ Նրանց վարքը համեմատելու համար օգտագործեցինք Jetty-ի, Http4s-ի և akka-http-ի վրա կառուցված երեք սերվեր։

TCP՝ ինչ է տեղի ունենում հարցումը չեղարկելիս

TCP մակարդակում իրադարձությունների հաջորդականությունը նույնն է՝ անկախ օգտագործվող կլիենտից։ Առայժմ կկենտրոնանանք HTTP/1.1-ի վրա։

Հարցումը չեղարկելիս կլիենտը փակում է հիմքում ընկած TCP կապը իր կողմից՝ ուղարկելով FIN փաթեթ։ Սերվերը հաստատում է այն, սակայն կապը մնում է կիսաբաց (սերվերը դեռ չի փակում իր կողմը)։

Մեր թեստում չեղարկումը տեղի է ունենում 1 վայրկյան անց, իսկ սերվերը սկսում է տվյալներ ուղարկել 2 վայրկյան անց։ Երբ այդ պահը գալիս է և սերվերն ուղարկում է առաջին տվյալների շրջանակները, դրանց համար հաստատումներ չեն գալիս, քանի որ կլիենտի կողմի սոկետը փակ է։ Փոխարենը կլիենտը պատասխանում է RST (reset) փաթեթներով։

Այս պահին սերվերը դադարեցնում է պատասխանի մնացած մասի ուղարկումը։ Թեստում սովորաբար փոխանցվում էր մոտ 32K տվյալ (ամբողջ 100MB-ի փոխարեն), ինչը հսկայական խնայողություն է։

Հիշեք, որ սերվերը «իմանում է», որ սոկետը փակ է, միայն երբ փորձում է ուղարկել պատասխանի որոշ տվյալներ։ Ինչպես ներածության մեջ ասացինք, սերվերի կողմի մշակումը չի կարող ընդհատվել և սովորաբար ավարտվում է մինչև վերջ։

Ստորև ներկայացված է Wireshark-ով գրանցված թեստի մեկ գործարկման նկարը՝

Երբ հարցումը չեղարկվում է, կապը փակվում է՝ անկախ Keep-Alive header-ների արժեքից։ Արդեն բաց կապը վերօգտագործելու փոխարեն նոր կապ հաստատելը կարող է վնասել արտադրողականությանը։ Ուստի կարող է նաև խելամիտ լինել հարցումները ընդհանրապես չչեղարկել և փոխարենը պահել կապը բաց։

async-http-client

Ստորև async-http-client-ով թեստի օրինակային գործարկում է։ Զանգ կատարելը վերադարձնում է Future-ի սեփական իրականացում, որն ունի cancel մեթոդ (կոդը Scala-ով է, բայց դրա համարժեքը կարելի է գրել ցանկացած JVM լեզվով)։

import org.asynchttpclient.DefaultAsyncHttpClient
import org.slf4j.LoggerFactory
import sys.process._

object Run extends App {
  val log = LoggerFactory.getLogger(this.getClass)
  val client = new DefaultAsyncHttpClient()

  val p = "/Applications/Wireshark.app/Contents/MacOS/wireshark -i lo0 -k -a duration:10".run()
  Thread.sleep(3000) // wait for Wireshark to start

  log.info("Sending ...")
  val f = client.executeRequest(
      client.prepareGet("http://localhost:8080/wait").build())
  log.info("Sent ...")
  Thread.sleep(1000)

  f.cancel(true)

  log.info("Done.")
}

Դրանից բացի, սկզբում գործարկում ենք Wireshark-ի գրառում։ Առանցքային կանչը, բնականաբար, f.cancel(true)-ն է։ Արդյունքը .get-ով ստանալու ցանկացած հետագա փորձ բացառություն է նետում։

async-http-client-ն առաջարկում է նաև .abort(Throwable), բայց թվում է, որ այն կատարում է չեղարկման ժամանակ աշխատող տրամաբանության միայն մի մասը, ուստի cancel-ն ավելի լավ ընտրություն է թվում։ Սակայն TCP մակարդակում երկուսն էլ նույն կերպ են վարվում։

Քանի որ պատասխանի տվյալները երբեք չեն հասնում, կլիենտը չի վերլուծում կամ այլ կերպ մշակում դրանք։

HttpClient

Java-ի ներկառուցված HttpClient-ի դեպքում կոդը գրեթե նույնն է։ .sendAsync-ով հարցում ուղարկելը նույնպես վերադարձնում է Future-ի իրականացում, որը կարելի է չեղարկել։

Այնուամենայնիվ, մինչև JDK 15 չեղարկումը ոչինչ չի անում։ JDK 16-ից սկսած՝ այն վարվում է հենց այնպես, ինչպես async-http-client-ի դեպքում։

HttpClient՝ Loom-ի վիրտուալ թելերով

Վիրտուալ թելերը (virtual threads) Java 19-ում preview հնարավորություն են և նախատեսված են հիմնականում վերացնելու ասինխրոն կոդի և Future-ների հետ աշխատելու անհրաժեշտությունը։ Հնարավո՞ր է չեղարկել ընթացքի մեջ գտնվող սինխրոն HTTP հարցումը։ Պարզվում է՝ դա հիանալի աշխատում է։ Փորձարկված է JDK20-ով։

import org.slf4j.LoggerFactory
import java.net.URI
import java.net.http.HttpResponse.BodyHandlers
import java.net.http.{HttpClient, HttpRequest}
import scala.sys.process._

object Run extends App {
  val log = LoggerFactory.getLogger(this.getClass)
  val client = HttpClient.newHttpClient()

  val p = "/Applications/Wireshark.app/Contents/MacOS/wireshark -i lo0 -k -a duration:10".run()
  Thread.sleep(3000) // wait for Wireshark to start

  log.info("Starting virtual thread ...")

  val t = Thread.startVirtualThread(() => {
    log.info("Sending ...")
    val r = client.send(
      HttpRequest
          .newBuilder(new URI("http://localhost:8080/wait"))
            .GET().version(HttpClient.Version.HTTP_1_1)
              .build(),
      BodyHandlers.ofString()
    )
    log.info(s"Received, body length: ${r.body().length}")
  })

  Thread.sleep(1000)
  log.info("Interrupting ...")
  t.interrupt()

  log.info("Done.")
}

Այս դեպքում առանցքային գործողությունը t.interrupt()-ն է, որը չեղարկում է ընթացքի մեջ գտնվող HTTP հարցումը՝ վերը նկարագրված հետևանքներով։

OkHttp

OkHttp-ի դեպքում և՛ սինխրոն, և՛ ասինխրոն եղանակով հարցում ուղարկելը վարվում է մոտավորապես այնպես, ինչպես վերևում նկարագրեցինք։ Ասինխրոն հարցումը մեզ տալիս է Future-ի նման արժեք, որը կարելի է չեղարկել, իսկ սինխրոն դեպքում կարող ենք ընդհատել հարցումը կատարող թելը։

Սակայն երբ OkHttp հարցումն ընդհատվում է, թելի interrupted դրոշակը մնում է դրված։ Արդյունքում ցանկացած հետագա արգելափակող գործողություն (օրինակ՝ finally բլոկի ներսում) անմիջապես կնետի InterruptedException, ինչը կարող է մեզ պետք չլինել։

Http4s

Համեմատության համար դիտարկենք cats-effect էկոհամակարգի գրադարանով ուղարկված հարցում։ Cats-effect-ը զուգահեռ ծրագրավորման գրադարան է, ինչպես նաև ասինխրոն runtime (հասանելի Scala-ի համար JVM-ում, JS-ում և Native-ում)։ Այն ունի թեթև թելերի (անվանվում են fiber-ներ) իր սեփական հայեցակարգը և պահանջում է մի փոքր այլ ծրագրավորման ոճ։

Ահա մեր կլիենտի կոդը։

import cats.effect._
import org.http4s.ember.client.EmberClientBuilder
import org.slf4j.LoggerFactory
import scala.concurrent.duration.DurationInt
import sys.process._

object Run extends IOApp {
  private val log = LoggerFactory.getLogger(this.getClass)

  override def run(args: List[String]): IO[ExitCode] = EmberClientBuilder
    .default[IO]
    .build
    .use { client =>
      for {
        _ <- IO("/Applications/Wireshark.app/Contents/MacOS/wireshark -i lo0 -k -a duration:10".run())
        _ <- IO.sleep(3.seconds)
        _ <- IO(log.info("Sending ..."))
        f <- client
          .expect[String]("http://localhost:8080/wait")
          .start
        _ <- IO(log.info("Sent ..."))
        _ <- IO.sleep(1.second)
        _ <- IO(log.info("Cancelling ..."))
        _ <- f.cancel
        _ <- IO(log.info("Done."))
      } yield ()
    }
    .as(ExitCode.Success)
}

for-comprehension-ի շնորհիվ ներդրված էֆեկտների նկարագրությունները կատարվում են հաջորդաբար։ .start գործողությունը սկսում է կատարել այն էֆեկտով նկարագրված հաշվարկը, որի վրա կանչվել է, ֆոնային ռեժիմով նոր fiber-ի վրա։ Այս դեպքում դա նշանակում է, որ HTTP հարցումը կատարվում է զուգահեռաբար։

Fiber-ը կարելի է չեղարկել f.cancel-ով – և հենց դրան ենք մենք ապավինում HTTP հարցումը չեղարկելու համար։

(Վիրտուալ) թելը ընդհատելը և fiber-ը չեղարկելը տարբերվում են մի քանի էական առումներով։ Դրանցից մեկն այն է, որ fiber-ի չեղարկումը լռելյայն back-pressure է կիրառում, այսինքն՝ սպասում է, մինչև fiber-ն ավարտվի (կարող են լինել, օրինակ, որոշ finalizer-ներ)։ Թելի դեպքում նույն արդյունքը ստանալու համար .interrupt()-ից հետո պետք է կանչել .join()։ Այս ձևավորման որոշումը թույլ է տալիս cats-effect-ին ապահովել ռեսուրսների նույնիսկ ավելի ուժեղ անվտանգություն, քան այլընտրանքները։

HTTP/2

Նույն թեստը HTTP/2-ով (աջակցվում է Java-ի HttpClient-ի և Jetty-ի կողմից) գործարկելը բացահայտում է մեկ առանցքային տարբերություն. հարցումը չեղարկելուց հետո կապը մնում է բաց։ Փոխարենը ուղարկվում է RST_STREAM փաթեթ, որը փակում է այդ կապի վրա բազմապլեքսավորված հոսքերից միայն մեկը։

Արդյունքում կապերը դեռ կարելի է վերօգտագործել, ուստի հարցում ուղարկելիս խուսափում ենք նոր կապ հաստատելու ծախսից՝ միաժամանակ շարունակելով խուսափել ավելորդ տվյալների փոխանցումից։

Streaming

Մենք լրացուցիչ փորձարկեցինք սցենար endpoint-ով, որը տվյալները կլիենտին հոսքով ուղարկում է մաս-մաս։ Մեր թեստում դա նշանակում էր 1KB տվյալների հատվածներ ուղարկել ամեն 100 միլիվայրկյանը մեկ՝ 3 վայրկյանի ընթացքում։ Ինչպես նախկինում, կլիենտը չեղարկում էր հարցումը 1 վայրկյան անց։

Արդյունքը գրեթե նույնն է. կլիենտը ստացել է առաջին վայրկյանի տվյալները, ապա ուղարկել FIN փաթեթ, որը փակել է սոկետը իր կողմից։ Երբ հաջորդ տվյալների հատվածը հասնում է, կլիենտը պատասխանում է RST-ով։

Սերվերի համար մենք իրականացրինք streaming-ը երկու տարբերակով՝ akka-http-ով և http4s-ով, քանի որ երկու գրադարաններն էլ հեշտացնում են streaming endpoint-ների սահմանումը։ Երբ կլիենտը փակում է կապը, հոսքն ավարտվում է IOException: Broken pipe-ով։

Այսպիսով, այս սցենարում կլիենտի կողմի չեղարկումը հասնում է սերվերին, ինչը թույլ է տալիս խուսափել հոսքի հետագա տարրեր արտադրելու ավելորդ աշխատանքից։

Եզրակացություններ

Ահա մեր ուսումնասիրության բացահայտումների ամփոփումը։

  • չեղարկումն աջակցող http կլիենտներն են՝ async-http-client, Java-ի ներկառուցված HttpClient (JDK 16-ից սկսած), OkHttp և http4s
  • չեղարկումը չաջակցող http կլիենտների թվում են Java-ի ներկառուցված HttpClient-ը (JDK 16-ից առաջ) և akka-http-ը
  • HTTP/1.1-ի դեպքում HTTP հարցումը չեղարկելը փակում է կապը։ HTTP/2-ի դեպքում կապը մնում է բաց և կարող է վերօգտագործվել այլ հարցումների համար
  • սերվերը «իմանում է», որ կապը փակ է, միայն երբ փորձում է ուղարկել պատասխանի առաջին շրջանակները, ուստի որոշ տվյալներ միշտ փոխանցվում են
  • Loom նախագծի (Virtual Threads) դեպքում HttpClient-ով կամ OkHttp-ով ուղարկված հարցումները կարելի է չեղարկել՝ ընդհատելով այն թելը, որի վրա դրանք աշխատում են. սակայն OkHttp-ը թողնում է interrupted դրոշակը դրված
  • երբ սերվերը պատասխանի տվյալներն արտադրում է աստիճանաբար, չեղարկումը կարող է տարածվել կլիենտից և փակել հոսքը սերվերի կողմում