ക്വാർക്കസ് ഒരു സൂപ്പർസോണിക് സബ് ആറ്റോമിക് ജാവയാണ്. ചട്ടക്കൂടിന്റെ ഹ്രസ്വ അവലോകനം

ആമുഖം

മാർച്ച് XNUMX-ന്, RedHat (ഉടൻ IBM) представила പുതിയ ചട്ടക്കൂട് - ക്വാർക്കസ്. ഡവലപ്പർമാർ പറയുന്നതനുസരിച്ച്, ഈ ചട്ടക്കൂട് GraalVM, OpenJDK HotSpot എന്നിവയെ അടിസ്ഥാനമാക്കിയുള്ളതാണ്, ഇത് കുബർനെറ്റസിനായി രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്നു. ക്വാർക്കസ് സ്റ്റാക്കിൽ ഉൾപ്പെടുന്നു: JPA/Hibernate, JAX-RS/RESTEasy, Eclipse Vert.x, Netty, Apache Camel, Kafka, Prometheus എന്നിവയും മറ്റും.

കുബർനെറ്റസ് വിന്യാസത്തിനും സെർവർലെസ് ആപ്ലിക്കേഷൻ ഡെവലപ്‌മെന്റിനുമുള്ള മുൻനിര പ്ലാറ്റ്‌ഫോമായി ജാവയെ മാറ്റുക എന്നതാണ് ലക്ഷ്യം, ഡവലപ്പർമാർക്ക് റിയാക്ടീവും നിർബന്ധിതവുമായ ശൈലികളിൽ വികസനത്തിന് ഒരു ഏകീകൃത സമീപനം നൽകുന്നു.

നിങ്ങൾ നോക്കിയാൽ ഇത് ചട്ടക്കൂടുകളുടെ വർഗ്ഗീകരണം, തുടർന്ന് ക്വാർക്കസ് "അഗ്രിഗേറ്ററുകൾ/കോഡ് ജനറേറ്ററുകൾ", "ഹൈ-ലെവൽ ഫുൾസ്റ്റാക്ക് ഫ്രെയിംവർക്കുകൾ" എന്നിവയ്ക്കിടയിലുള്ളതാണ്. ഇത് ഇതിനകം ഒരു അഗ്രഗേറ്ററിനേക്കാൾ കൂടുതലാണ്, പക്ഷേ ഇത് പൂർണ്ണ-സ്റ്റാക്കിൽ പോലും എത്തിയില്ല, കാരണം... ബാക്ക്എൻഡ് വികസനത്തിന് അനുയോജ്യമായതാണ്.

ആപ്ലിക്കേഷൻ ലോഞ്ചിന്റെ ഉയർന്ന വേഗതയും കുറഞ്ഞ മെമ്മറി ഉപഭോഗവും വാഗ്ദാനം ചെയ്യുന്നു. ഡെവലപ്പറുടെ വെബ്‌സൈറ്റിൽ നിന്നുള്ള ഡാറ്റ ഇതാ:

തുടക്കം മുതൽ ആദ്യ പ്രതികരണം വരെയുള്ള സമയം (കൾ):

കോൺഫിഗറേഷൻ
REST
REST+JPA

ക്വാർക്കസ്+ഗ്രാൽവിഎം
0.014
0.055

ക്വാർക്കസ്+ഓപ്പൺജെഡികെ
0.75
2.5

പരമ്പരാഗത ക്ലൗഡ് നേറ്റീവ് സ്റ്റാക്ക്*
4.3
9.5

മെമ്മറി ഉപഭോഗം (Mb):

കോൺഫിഗറേഷൻ
REST
REST+JPA

ക്വാർക്കസ്+ഗ്രാൽവിഎം
13
35

ക്വാർക്കസ്+ഓപ്പൺജെഡികെ
74
130

പരമ്പരാഗത ക്ലൗഡ് നേറ്റീവ് സ്റ്റാക്ക്*
140
218

ശ്രദ്ധേയമാണ്, അല്ലേ?

*ഈ ടെക്‌നോളജി സ്റ്റാക്കിനെക്കുറിച്ച് ഒരു വിവരവും ഞാൻ കണ്ടെത്തിയില്ല, ഇത് ഒരു അധിക ബോഡി കിറ്റുള്ള ഒരുതരം സ്പ്രിംഗ് ബൂട്ടാണെന്ന് നമുക്ക് അനുമാനിക്കാം.

ഹലോ വേൾഡ്!

ക്വാർക്കസിൽ എഴുതിയ ഏറ്റവും ലളിതമായ ആപ്ലിക്കേഷൻ ഇതുപോലെ കാണപ്പെടും:

@Path("/hello")
public class GreetingResource {

   @GET
   @Produces(MediaType.TEXT_PLAIN)
   public String hello() {
       return "hello";
   }
}

ഇത് അക്ഷരാർത്ഥത്തിൽ ഒരു ക്ലാസ് ആണ്, അത് മതി! വികസന മോഡിൽ Maven ഉപയോഗിച്ച് നിങ്ങൾക്ക് ആപ്ലിക്കേഷൻ പ്രവർത്തിപ്പിക്കാൻ കഴിയും:

mvn compile quarkus:dev
…
$ curl http://localhost:8080/hello
hello

ഒരു സാധാരണ ആപ്ലിക്കേഷനിൽ നിന്നുള്ള വ്യത്യാസം ആപ്ലിക്കേഷൻ ക്ലാസ് ഇല്ല എന്നതാണ്! Quarkus ഹോട്ട് റീലോഡിനെ പിന്തുണയ്ക്കുന്നു, അതിനാൽ നിങ്ങളുടെ ആപ്ലിക്കേഷൻ പുനരാരംഭിക്കാതെ തന്നെ നിങ്ങൾക്ക് മാറ്റാനാകും, ഇത് വികസനം കൂടുതൽ വേഗത്തിലാക്കുന്നു.

അടുത്തത് എന്താണ്? ഒരു വ്യാഖ്യാനം ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഒരു കൺട്രോളറിലേക്ക് ഒരു സേവനം ചേർക്കാൻ കഴിയും കുത്തിവയ്ക്കുക. സേവന കോഡ്:

@ApplicationScoped
public class GreetingService {

   public String greeting(String name) {
       return "Hello " + name + "!";
   }
}

കണ്ട്രോളർ:

@Path("/hello")
public class GreetingResource {

   @Inject
   GreetingService service;

   @GET
   @Produces(MediaType.TEXT_PLAIN)
   @Path("/{name}")
   public String greeting(@PathParam("name") String name) {
       return service.greeting(name);
   }
}

$ curl http://localhost:8080/hello/developer
Hello developer!

CDI, JAX-RS - പരിചിതമായ ചട്ടക്കൂടുകളിൽ നിന്നുള്ള സ്റ്റാൻഡേർഡ് വ്യാഖ്യാനങ്ങളാണ് ക്വാർക്കസ് ഉപയോഗിക്കുന്നത് എന്നത് ശ്രദ്ധിക്കുക. നിങ്ങൾ മുമ്പ് CDI, JAX-RS എന്നിവയിൽ പ്രവർത്തിച്ചിട്ടുണ്ടെങ്കിൽ പുതിയതായി ഒന്നും പഠിക്കേണ്ടതില്ല.

ഡാറ്റാബേസുമായി പ്രവർത്തിക്കുന്നു

എന്റിറ്റികൾക്കായി ഹൈബർനേറ്റ്, സ്റ്റാൻഡേർഡ് ജെപിഎ വ്യാഖ്യാനങ്ങൾ ഉപയോഗിക്കുന്നു. REST കൺട്രോളറുകൾ പോലെ, നിങ്ങൾ കുറഞ്ഞത് ഒരു കോഡ് എഴുതേണ്ടതുണ്ട്. അസംബ്ലി ഫയലിലെ ഡിപൻഡൻസികൾ സൂചിപ്പിച്ചാൽ മതി, വ്യാഖ്യാനങ്ങൾ ചേർക്കുക @Entity കൂടാതെ application.properties-ൽ ഡാറ്റ സോഴ്സ് കോൺഫിഗർ ചെയ്യുക.

എല്ലാം. sessionFactory, persistence.xml അല്ലെങ്കിൽ മറ്റ് സേവന ഫയലുകളൊന്നുമില്ല. ആവശ്യമുള്ള കോഡ് മാത്രമാണ് ഞങ്ങൾ എഴുതുന്നത്. എന്നിരുന്നാലും, ആവശ്യമെങ്കിൽ, നിങ്ങൾക്ക് persistence.xml ഫയൽ സൃഷ്ടിക്കാനും ORM ലെയർ കൂടുതൽ നന്നായി ക്രമീകരിക്കാനും കഴിയും.

ക്വാർക്കസ് എന്റിറ്റികളുടെ കാഷിംഗ്, ഒന്നിൽ നിന്ന് നിരവധി ബന്ധങ്ങൾക്കുള്ള ശേഖരങ്ങൾ, അന്വേഷണങ്ങൾ എന്നിവ പിന്തുണയ്ക്കുന്നു. ഒറ്റനോട്ടത്തിൽ ഇത് വളരെ മികച്ചതായി തോന്നുന്നു, പക്ഷേ അത് പ്രാദേശികമായ ഒരു കുബർനെറ്റസ് നോഡിനായി കാഷെ ചെയ്യുന്നു. ആ. വ്യത്യസ്ത നോഡുകളുടെ കാഷെകൾ പരസ്പരം സമന്വയിപ്പിച്ചിട്ടില്ല. ഇത് താൽക്കാലികമാണെന്ന് ഞാൻ പ്രതീക്ഷിക്കുന്നു.

അസിൻക്രണസ് കോഡ് എക്സിക്യൂഷൻ

മുകളിൽ സൂചിപ്പിച്ചതുപോലെ, റിയാക്ടീവ് പ്രോഗ്രാമിംഗ് ശൈലിയും ക്വാർക്കസ് പിന്തുണയ്ക്കുന്നു. മുമ്പത്തെ ആപ്ലിക്കേഷന്റെ കോഡ് മറ്റൊരു രൂപത്തിൽ എഴുതാം.

@Path("/hello")
public class GreetingResource {

   @GET
   @Produces(MediaType.TEXT_PLAIN)
   @Path("/{name}")
   public CompletionStage<String> greeting(@PathParam("name") String name) {
       return CompletableFuture.supplyAsync(() -> {
           return "Hello " + name + "!";
       });
   }
}

അസിൻക്രണസ് കോഡും സേവനത്തിലേക്ക് കൈമാറാൻ കഴിയും, ഫലം സമാനമായിരിക്കും.

പരിശോധിക്കുന്നു

ക്വാർക്കസ് ആപ്ലിക്കേഷനുകൾക്കുള്ള ടെസ്റ്റുകൾ JUnit4 അല്ലെങ്കിൽ JUnit5 ൽ എഴുതാം. ഒരു എൻഡ്‌പോയിന്റിനായുള്ള ഒരു ഉദാഹരണ പരിശോധന ചുവടെയുണ്ട്, ഇത് RestAssured ഉപയോഗിച്ചാണ് എഴുതിയിരിക്കുന്നത്, എന്നാൽ മറ്റൊരു ചട്ടക്കൂട് ഉപയോഗിക്കാം:

@QuarkusTest
public class GreetingResourceTest {

   @Test
   public void testGreetingEndpoint() {
       String uuid = UUID.randomUUID().toString();
       given()
         .pathParam("name", uuid)
         .when().get("/hello/{name}")
         .then()
           .statusCode(200)
           .body(is("Hello " + uuid + "!"));
   }
}

@QuarkusTest വ്യാഖ്യാനം ടെസ്റ്റുകൾ പ്രവർത്തിപ്പിക്കുന്നതിന് മുമ്പ് ആപ്ലിക്കേഷൻ പ്രവർത്തിപ്പിക്കാൻ നിർദ്ദേശിക്കുന്നു. ബാക്കിയുള്ളത് എല്ലാ ഡെവലപ്പർമാർക്കും പരിചിതമായ കോഡാണ്.

പ്ലാറ്റ്ഫോം-നിർദ്ദിഷ്ട ആപ്ലിക്കേഷൻ

ക്വാർക്കസ് GraalVM-മായി കർശനമായി സംയോജിപ്പിച്ചിരിക്കുന്നതിനാൽ, പ്ലാറ്റ്ഫോം-നിർദ്ദിഷ്ട കോഡ് സൃഷ്ടിക്കുന്നത് തീർച്ചയായും സാധ്യമാണ്. ഇത് ചെയ്യുന്നതിന്, നിങ്ങൾ GraalVM ഇൻസ്റ്റാൾ ചെയ്യുകയും GRAALVM_HOME എൻവയോൺമെന്റ് വേരിയബിൾ വ്യക്തമാക്കുകയും വേണം. കൂടുതൽ അസംബ്ലിക്കായി ഒരു പ്രൊഫൈൽ രജിസ്റ്റർ ചെയ്യുക ആപ്ലിക്കേഷൻ നിർമ്മിക്കുമ്പോൾ അത് വ്യക്തമാക്കുക:

mvn package -Pnative

രസകരമെന്നു പറയട്ടെ, ജനറേറ്റുചെയ്‌ത ആപ്ലിക്കേഷൻ പരീക്ഷിക്കാൻ കഴിയും. ഇത് പ്രധാനമാണ്, കാരണം നേറ്റീവ് കോഡിന്റെ നിർവ്വഹണം ജെവിഎമ്മിലെ എക്സിക്യൂഷനിൽ നിന്ന് വ്യത്യസ്തമായിരിക്കും. @SubstrateTest വ്യാഖ്യാനം പ്ലാറ്റ്‌ഫോം-നിർദ്ദിഷ്ട ആപ്ലിക്കേഷൻ കോഡ് പ്രവർത്തിപ്പിക്കുന്നു. നിലവിലുള്ള ടെസ്റ്റ് കോഡ് പുനരുപയോഗിക്കുന്നത് അനന്തരാവകാശം ഉപയോഗിച്ച് ചെയ്യാം; തൽഫലമായി, ഒരു പ്ലാറ്റ്‌ഫോം ആശ്രിത ആപ്ലിക്കേഷൻ പരിശോധിക്കുന്നതിനുള്ള കോഡ് ഇതുപോലെ കാണപ്പെടും:

@SubstrateTest
public class GreetingResourceIT extends GreetingResourceTest {

}

ജനറേറ്റുചെയ്‌ത ചിത്രം ഡോക്കറിൽ പാക്കേജുചെയ്‌ത് കുബർനെറ്റസിലോ ഓപ്പൺഷിഫ്റ്റിലോ പ്രവർത്തിപ്പിക്കാം, വിശദമായി വിവരിക്കുന്നു നിർദ്ദേശങ്ങൾ.

ടൂൾകിറ്റ്

ക്വാർക്കസ് ചട്ടക്കൂട് Maven, Gradle എന്നിവയ്‌ക്കൊപ്പം ഉപയോഗിക്കാം. Gradle-ൽ നിന്ന് വ്യത്യസ്തമായി Maven പൂർണ്ണമായും പിന്തുണയ്ക്കുന്നു. നിർഭാഗ്യവശാൽ, ഇപ്പോൾ ഒരു ശൂന്യമായ പ്രോജക്റ്റ് സൃഷ്ടിക്കുന്നതിനെ Gradle പിന്തുണയ്ക്കുന്നില്ല; വെബ്സൈറ്റിൽ വിശദമായ വിവരങ്ങൾ ഉണ്ട് പാഠപുസ്തകം.

വിപുലീകരണങ്ങൾ

ക്വാർക്കസ് ഒരു വിപുലീകരിക്കാവുന്ന ചട്ടക്കൂടാണ്. നിലവിൽ ഒരു ഓർഡർ ഉണ്ട് 40 വിപുലീകരണങ്ങൾ, വിവിധ പ്രവർത്തനങ്ങൾ ചേർക്കുന്നു - പിന്തുണയിൽ നിന്ന് സ്പ്രിംഗ് ഡിഐ കണ്ടെയ്നർ и അപ്പാച്ചെ ഒട്ടകം ലോഗിൻ ചെയ്യുന്നതിനും സേവനങ്ങൾ പ്രവർത്തിപ്പിക്കുന്നതിനുള്ള മെട്രിക്‌സ് പ്രസിദ്ധീകരിക്കുന്നതിനും മുമ്പ്. ജാവയ്‌ക്ക് പുറമേ, കോട്‌ലിനിൽ റൈറ്റിംഗ് ആപ്ലിക്കേഷനുകളെ പിന്തുണയ്ക്കുന്നതിന് ഇതിനകം ഒരു വിപുലീകരണമുണ്ട്.

തീരുമാനം

എന്റെ അഭിപ്രായത്തിൽ, ക്വാർക്കസ് അക്കാലത്തെ ട്രെൻഡുകളുമായി തികച്ചും യോജിക്കുന്നു. ബാക്ക്‌എൻഡ് കോഡ് ഡെവലപ്‌മെന്റ് എളുപ്പവും എളുപ്പവുമാണ്, ഈ ചട്ടക്കൂട് ഡോക്കറിനും കുബർനെറ്റസിനും നേറ്റീവ് പിന്തുണ ചേർത്ത് സേവന വികസനം കൂടുതൽ ലളിതമാക്കുകയും വേഗത്തിലാക്കുകയും ചെയ്യുന്നു. GraalVM-നുള്ള ബിൽറ്റ്-ഇൻ പിന്തുണയും പ്ലാറ്റ്‌ഫോം-ആശ്രിത ഇമേജുകളുടെ ജനറേഷനും ഒരു വലിയ പ്ലസ് ആണ്, ഇത് സേവനങ്ങൾ വളരെ വേഗത്തിൽ ആരംഭിക്കാനും കുറച്ച് മെമ്മറി ഇടം എടുക്കാനും അനുവദിക്കുന്നു. മൈക്രോസർവീസുകളോടും സെർവർലെസ് ആർക്കിടെക്ചറിനോടുമുള്ള നമ്മുടെ വൻ അഭിനിവേശത്തിൽ ഇത് വളരെ പ്രധാനമാണ്.

ഔദ്യോഗിക സൈറ്റ് - quarkus.io. വേഗത്തിൽ ആരംഭിക്കുന്നതിനുള്ള പ്രോജക്റ്റുകളുടെ ഉദാഹരണങ്ങൾ ഇതിനകം ലഭ്യമാണ് സാമൂഹികം.

അവലംബം: www.habr.com