ಕ್ವಾರ್ಕಸ್ ಒಂದು ಸೂಪರ್ಸಾನಿಕ್ ಸಬ್ಟಾಮಿಕ್ ಜಾವಾ. ಚೌಕಟ್ಟಿನ ಸಂಕ್ಷಿಪ್ತ ಅವಲೋಕನ

ಪರಿಚಯ

ಮಾರ್ಚ್ XNUMX ರಂದು, RedHat (ಶೀಘ್ರದಲ್ಲೇ IBM) ಪ್ರಸ್ತುತಪಡಿಸಲಾಗಿದೆ ಹೊಸ ಚೌಕಟ್ಟು - ಕ್ವಾರ್ಕಸ್. ಡೆವಲಪರ್‌ಗಳ ಪ್ರಕಾರ, ಈ ಫ್ರೇಮ್‌ವರ್ಕ್ GraalVM ಮತ್ತು OpenJDK ಹಾಟ್‌ಸ್ಪಾಟ್ ಅನ್ನು ಆಧರಿಸಿದೆ ಮತ್ತು ಕುಬರ್ನೆಟ್‌ಗಳಿಗಾಗಿ ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ. ಕ್ವಾರ್ಕಸ್ ಸ್ಟಾಕ್ ಒಳಗೊಂಡಿದೆ: JPA/Hibernate, JAX-RS/RESTEasy, Eclipse Vert.x, Netty, Apache Camel, Kafka, Prometheus ಮತ್ತು ಇತರರು.

ಕುಬರ್ನೆಟ್ಸ್ ನಿಯೋಜನೆ ಮತ್ತು ಸರ್ವರ್‌ಲೆಸ್ ಅಪ್ಲಿಕೇಶನ್ ಅಭಿವೃದ್ಧಿಗೆ ಜಾವಾವನ್ನು ಪ್ರಮುಖ ವೇದಿಕೆಯನ್ನಾಗಿ ಮಾಡುವುದು ಗುರಿಯಾಗಿದೆ, ಡೆವಲಪರ್‌ಗಳಿಗೆ ಪ್ರತಿಕ್ರಿಯಾತ್ಮಕ ಮತ್ತು ಕಡ್ಡಾಯ ಶೈಲಿಗಳಲ್ಲಿ ಅಭಿವೃದ್ಧಿಗೆ ಏಕೀಕೃತ ವಿಧಾನವನ್ನು ಒದಗಿಸುತ್ತದೆ.

ನೀವು ನೋಡಿದರೆ ಇದು ಚೌಕಟ್ಟುಗಳ ವರ್ಗೀಕರಣ, ನಂತರ ಕ್ವಾರ್ಕಸ್ ಎಲ್ಲೋ "ಅಗ್ರಿಗೇಟರ್‌ಗಳು/ಕೋಡ್ ಜನರೇಟರ್‌ಗಳು" ಮತ್ತು "ಉನ್ನತ ಮಟ್ಟದ ಫುಲ್‌ಸ್ಟಾಕ್ ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗಳ" ನಡುವೆ ಇರುತ್ತದೆ. ಇದು ಈಗಾಗಲೇ ಸಂಗ್ರಾಹಕಕ್ಕಿಂತ ಹೆಚ್ಚಾಗಿರುತ್ತದೆ, ಆದರೆ ಇದು ಪೂರ್ಣ-ಸ್ಟಾಕ್ ಅನ್ನು ಸಹ ತಲುಪುವುದಿಲ್ಲ, ಏಕೆಂದರೆ... ಬ್ಯಾಕೆಂಡ್ ಅಭಿವೃದ್ಧಿಗೆ ಅನುಗುಣವಾಗಿರುತ್ತದೆ.

ಅಪ್ಲಿಕೇಶನ್ ಉಡಾವಣೆಯ ಹೆಚ್ಚಿನ ವೇಗ ಮತ್ತು ಕಡಿಮೆ ಮೆಮೊರಿ ಬಳಕೆ ಭರವಸೆ ಇದೆ. ಡೆವಲಪರ್‌ಗಳ ವೆಬ್‌ಸೈಟ್‌ನಿಂದ ಡೇಟಾ ಇಲ್ಲಿದೆ:

ಪ್ರಾರಂಭದಿಂದ ಮೊದಲ ಪ್ರತಿಕ್ರಿಯೆಗೆ ಸಮಯ (ಗಳು):

ಸಂರಚನೆ
ಉಳಿದ
REST+JPA

ಕ್ವಾರ್ಕಸ್+ಗ್ರಾಲ್ವಿಎಂ
0.014
0.055

ಕ್ವಾರ್ಕಸ್+ಓಪನ್ಜೆಡಿಕೆ
0.75
2.5

ಸಾಂಪ್ರದಾಯಿಕ ಮೇಘ ಸ್ಥಳೀಯ ಸ್ಟಾಕ್*
4.3
9.5

ಮೆಮೊರಿ ಬಳಕೆ (Mb):

ಸಂರಚನೆ
ಉಳಿದ
REST+JPA

ಕ್ವಾರ್ಕಸ್+ಗ್ರಾಲ್ವಿಎಂ
13
35

ಕ್ವಾರ್ಕಸ್+ಓಪನ್ಜೆಡಿಕೆ
74
130

ಸಾಂಪ್ರದಾಯಿಕ ಮೇಘ ಸ್ಥಳೀಯ ಸ್ಟಾಕ್*
140
218

ಪ್ರಭಾವಶಾಲಿ, ಅಲ್ಲವೇ?

*ಈ ತಂತ್ರಜ್ಞಾನದ ಸ್ಟ್ಯಾಕ್ ಬಗ್ಗೆ ನನಗೆ ಯಾವುದೇ ಮಾಹಿತಿ ಸಿಗಲಿಲ್ಲ, ಇದು ಹೆಚ್ಚುವರಿ ಬಾಡಿ ಕಿಟ್‌ನೊಂದಿಗೆ ಕೆಲವು ರೀತಿಯ ಸ್ಪ್ರಿಂಗ್ ಬೂಟ್ ಎಂದು ನಾವು ಊಹಿಸಬಹುದು.

ಹಲೋ ವರ್ಲ್ಡ್!

ಕ್ವಾರ್ಕಸ್‌ನಲ್ಲಿ ಬರೆಯಲಾದ ಸರಳವಾದ ಅಪ್ಲಿಕೇಶನ್ ಈ ರೀತಿ ಕಾಣುತ್ತದೆ:

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

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

ಇದು ಅಕ್ಷರಶಃ ಒಂದು ವರ್ಗ ಮತ್ತು ಅದು ಸಾಕು! ಡೆವಲಪ್‌ಮೆಂಟ್ ಮೋಡ್‌ನಲ್ಲಿ ಮಾವೆನ್ ಬಳಸಿ ನೀವು ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಚಲಾಯಿಸಬಹುದು:

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

ಸಾಮಾನ್ಯ ಅಪ್ಲಿಕೇಶನ್‌ನಿಂದ ವ್ಯತ್ಯಾಸವೆಂದರೆ ಯಾವುದೇ ಅಪ್ಲಿಕೇಶನ್ ವರ್ಗವಿಲ್ಲ! ಕ್ವಾರ್ಕಸ್ ಹಾಟ್ ರೀಲೋಡ್ ಅನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ, ಆದ್ದರಿಂದ ನೀವು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಮರುಪ್ರಾರಂಭಿಸದೆಯೇ ಬದಲಾಯಿಸಬಹುದು, ಅಭಿವೃದ್ಧಿಯನ್ನು ಇನ್ನಷ್ಟು ವೇಗಗೊಳಿಸುತ್ತದೆ.

ಮುಂದೇನು? ಟಿಪ್ಪಣಿಯನ್ನು ಬಳಸಿಕೊಂಡು ನೀವು ನಿಯಂತ್ರಕಕ್ಕೆ ಸೇವೆಯನ್ನು ಸೇರಿಸಬಹುದು ಚುಚ್ಚುಮದ್ದು. ಸೇವಾ ಕೋಡ್:

@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 ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಿದ್ದರೆ ಹೊಸದನ್ನು ಕಲಿಯುವ ಅಗತ್ಯವಿಲ್ಲ.

ಡೇಟಾಬೇಸ್ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವುದು

ಘಟಕಗಳಿಗೆ ಹೈಬರ್ನೇಟ್ ಮತ್ತು ಪ್ರಮಾಣಿತ JPA ಟಿಪ್ಪಣಿಗಳನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. 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

ಕುತೂಹಲಕಾರಿಯಾಗಿ, ರಚಿಸಲಾದ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಪರೀಕ್ಷಿಸಬಹುದು. ಮತ್ತು ಇದು ಮುಖ್ಯವಾಗಿದೆ ಏಕೆಂದರೆ ಸ್ಥಳೀಯ ಕೋಡ್‌ನ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯು JVM ನಲ್ಲಿನ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಗಿಂತ ಭಿನ್ನವಾಗಿರಬಹುದು. @SubstrateTest ಟಿಪ್ಪಣಿಯು ಪ್ಲಾಟ್‌ಫಾರ್ಮ್-ನಿರ್ದಿಷ್ಟ ಅಪ್ಲಿಕೇಶನ್ ಕೋಡ್ ಅನ್ನು ರನ್ ಮಾಡುತ್ತದೆ. ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಪರೀಕ್ಷಾ ಕೋಡ್ ಅನ್ನು ಆನುವಂಶಿಕತೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಮಾಡಬಹುದು; ಪರಿಣಾಮವಾಗಿ, ಪ್ಲಾಟ್‌ಫಾರ್ಮ್-ಅವಲಂಬಿತ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಪರೀಕ್ಷಿಸುವ ಕೋಡ್ ಈ ರೀತಿ ಕಾಣುತ್ತದೆ:

@SubstrateTest
public class GreetingResourceIT extends GreetingResourceTest {

}

ರಚಿಸಲಾದ ಚಿತ್ರವನ್ನು ಡಾಕರ್‌ನಲ್ಲಿ ಪ್ಯಾಕ್ ಮಾಡಬಹುದು ಮತ್ತು ಕುಬರ್ನೆಟ್ಸ್ ಅಥವಾ ಓಪನ್‌ಶಿಫ್ಟ್‌ನಲ್ಲಿ ರನ್ ಮಾಡಬಹುದು, ಇದನ್ನು ವಿವರವಾಗಿ ವಿವರಿಸಲಾಗಿದೆ ಸೂಚನೆಗಳು.

ಟೂಲ್ಕಿಟ್

ಕ್ವಾರ್ಕಸ್ ಚೌಕಟ್ಟನ್ನು ಮಾವೆನ್ ಮತ್ತು ಗ್ರೇಡಲ್‌ನೊಂದಿಗೆ ಬಳಸಬಹುದು. ಗ್ರೇಡಲ್‌ಗಿಂತ ಭಿನ್ನವಾಗಿ ಮಾವೆನ್ ಸಂಪೂರ್ಣವಾಗಿ ಬೆಂಬಲಿತವಾಗಿದೆ. ದುರದೃಷ್ಟವಶಾತ್, ಈ ಸಮಯದಲ್ಲಿ ಗ್ರ್ಯಾಡಲ್ ಖಾಲಿ ಯೋಜನೆಯನ್ನು ರಚಿಸಲು ಬೆಂಬಲಿಸುವುದಿಲ್ಲ; ವೆಬ್‌ಸೈಟ್‌ನಲ್ಲಿ ವಿವರವಾದ ಮಾಹಿತಿ ಇದೆ ಪಠ್ಯಪುಸ್ತಕ.

ವಿಸ್ತರಣೆಗಳು

ಕ್ವಾರ್ಕಸ್ ಒಂದು ವಿಸ್ತರಿಸಬಹುದಾದ ಚೌಕಟ್ಟಾಗಿದೆ. ಪ್ರಸ್ತುತ ಆದೇಶವಿದೆ 40 ವಿಸ್ತರಣೆಗಳು, ಇದು ವಿವಿಧ ಕಾರ್ಯಗಳನ್ನು ಸೇರಿಸುತ್ತದೆ - ಬೆಂಬಲದಿಂದ ಸ್ಪ್ರಿಂಗ್ ಡಿಐ ಕಂಟೇನರ್ и ಅಪಾಚೆ ಒಂಟೆ ಚಾಲನೆಯಲ್ಲಿರುವ ಸೇವೆಗಳಿಗಾಗಿ ಮೆಟ್ರಿಕ್‌ಗಳನ್ನು ಲಾಗ್ ಮಾಡುವ ಮತ್ತು ಪ್ರಕಟಿಸುವ ಮೊದಲು. ಮತ್ತು ಜಾವಾ ಜೊತೆಗೆ ಕೋಟ್ಲಿನ್‌ನಲ್ಲಿ ಬರೆಯುವ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಬೆಂಬಲಿಸಲು ಈಗಾಗಲೇ ವಿಸ್ತರಣೆ ಇದೆ.

ತೀರ್ಮಾನಕ್ಕೆ

ನನ್ನ ಅಭಿಪ್ರಾಯದಲ್ಲಿ, ಕ್ವಾರ್ಕಸ್ ಆ ಕಾಲದ ಪ್ರವೃತ್ತಿಗಳಿಗೆ ಅನುಗುಣವಾಗಿದೆ. ಬ್ಯಾಕೆಂಡ್ ಕೋಡ್ ಅಭಿವೃದ್ಧಿಯು ಸುಲಭ ಮತ್ತು ಸುಲಭವಾಗುತ್ತಿದೆ, ಮತ್ತು ಈ ಚೌಕಟ್ಟು ಡಾಕರ್ ಮತ್ತು ಕುಬರ್ನೆಟ್‌ಗಳಿಗೆ ಸ್ಥಳೀಯ ಬೆಂಬಲವನ್ನು ಸೇರಿಸುವ ಮೂಲಕ ಸೇವಾ ಅಭಿವೃದ್ಧಿಯನ್ನು ಇನ್ನಷ್ಟು ಸರಳಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ವೇಗಗೊಳಿಸುತ್ತದೆ. GraalVM ಮತ್ತು ಪ್ಲಾಟ್‌ಫಾರ್ಮ್-ಅವಲಂಬಿತ ಚಿತ್ರಗಳ ಉತ್ಪಾದನೆಗೆ ಅಂತರ್ನಿರ್ಮಿತ ಬೆಂಬಲವು ಒಂದು ದೊಡ್ಡ ಪ್ಲಸ್ ಆಗಿದೆ, ಇದು ಸೇವೆಗಳನ್ನು ನಿಜವಾಗಿಯೂ ತ್ವರಿತವಾಗಿ ಪ್ರಾರಂಭಿಸಲು ಮತ್ತು ಕಡಿಮೆ ಮೆಮೊರಿ ಸ್ಥಳವನ್ನು ತೆಗೆದುಕೊಳ್ಳಲು ಅನುಮತಿಸುತ್ತದೆ. ಮತ್ತು ಮೈಕ್ರೋಸರ್ವಿಸ್ ಮತ್ತು ಸರ್ವರ್‌ಲೆಸ್ ಆರ್ಕಿಟೆಕ್ಚರ್‌ಗಾಗಿ ನಮ್ಮ ಸಾಮೂಹಿಕ ಉತ್ಸಾಹದ ಸಮಯದಲ್ಲಿ ಇದು ಬಹಳ ಮುಖ್ಯವಾಗಿದೆ.

ಅಧಿಕೃತ ಸೈಟ್ - quarkus.io. ತ್ವರಿತ ಪ್ರಾರಂಭಕ್ಕಾಗಿ ಯೋಜನೆಗಳ ಉದಾಹರಣೆಗಳು ಈಗಾಗಲೇ ಲಭ್ಯವಿದೆ GitHub.

ಮೂಲ: www.habr.com