Panduan untuk QuarkusIO

1. Perkenalan

Saat ini, sangat umum untuk menulis aplikasi dan menerapkannya ke cloud dan tidak mengkhawatirkan infrastruktur. Tanpa server dan FaaS telah menjadi sangat populer.

Dalam jenis lingkungan ini, di mana instance sering dibuat dan dimusnahkan, waktu untuk booting dan waktu untuk permintaan pertama sangat penting, karena mereka dapat menciptakan pengalaman pengguna yang sama sekali berbeda.

Bahasa seperti JavaScript dan Python selalu menjadi sorotan dalam skenario jenis ini. Dengan kata lain, Java dengan JAR yang gemuk dan waktu boot yang lama tidak pernah menjadi pesaing utama.

Dalam tutorial ini, kami akan menyajikan Quarkus dan membahas apakah itu alternatif untuk membawa Java secara lebih efektif ke cloud .

2. QuarkusIO

QuarkusIO, Supersonic Subatomic Java, berjanji untuk mengirimkan artefak kecil, waktu boot yang sangat cepat, dan waktu-ke-permintaan-pertama yang lebih rendah. Saat digabungkan dengan GraalVM, Quarkus akan melakukan kompilasi di depan waktu (AOT).

Dan, karena Quarkus dibangun di atas standar, kita tidak perlu mempelajari hal baru. Alhasil, kita bisa menggunakan CDI dan JAX-RS, antara lain. Selain itu, Quarkus memiliki banyak ekstensi, termasuk yang mendukung Hibernate, Kafka, OpenShift, Kubernetes, dan Vert.x.

3. Aplikasi Pertama Kami

Cara termudah untuk membuat proyek Quarkus baru adalah dengan membuka terminal dan mengetik:

mvn io.quarkus:quarkus-maven-plugin:0.13.1:create \ -DprojectGroupId=com.baeldung.quarkus \ -DprojectArtifactId=quarkus-project \ -DclassName="com.baeldung.quarkus.HelloResource" \ -Dpath="/hello"

Ini akan menghasilkan kerangka proyek, HelloResource dengan titik akhir / hello terpapar, konfigurasi, proyek Maven, dan Dockerfiles.

Setelah diimpor ke IDE kami, kami akan memiliki struktur yang mirip dengan yang ditunjukkan pada gambar di bawah ini:

Mari kita periksa konten kelas HelloResource :

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

Semuanya terlihat bagus sejauh ini. Pada titik ini, kami memiliki aplikasi sederhana dengan satu titik akhir RESTEasy JAX-RS. Mari lanjutkan dan uji dengan membuka terminal dan menjalankan perintah:

./mvnw compile quarkus:dev:

Endpoint REST kami harus diekspos di localhost: 8080 / hello. Mari kita uji dengan perintah curl :

$ curl localhost:8080/hello hello

4. Hot Reload

Saat berjalan dalam mode pengembangan ( ./mvn compile quarkus: dev ), Quarkus menyediakan kemampuan hot-reload. Dengan kata lain, perubahan yang dibuat pada file Java atau file konfigurasi akan secara otomatis dikompilasi setelah browser di-refresh . Fitur yang paling mengesankan di sini adalah kita tidak perlu menyimpan file kita. Ini bisa baik atau buruk, tergantung pada preferensi kita.

Kami sekarang akan memodifikasi contoh kami untuk mendemonstrasikan kemampuan hot-reload. Jika aplikasi dihentikan, kita dapat memulai ulang dalam mode pengembang. Kami akan menggunakan contoh yang sama seperti sebelumnya sebagai titik awal kami.

Pertama, kita akan membuat kelas HelloService :

@ApplicationScoped public class HelloService { public String politeHello(String name){ return "Hello Mr/Mrs " + name; } }

Sekarang, kita akan memodifikasi kelas HelloResource , memasukkan HelloService dan menambahkan metode baru:

@Inject HelloService helloService; @GET @Produces(MediaType.APPLICATION_JSON) @Path("/polite/{name}") public String greeting(@PathParam("name") String name) { return helloService.politeHello(name); }

Selanjutnya, mari kita uji titik akhir baru kita:

$ curl localhost:8080/hello/polite/Baeldung Hello Mr/Mrs Baeldung

Kami akan membuat satu perubahan lagi untuk menunjukkan bahwa hal yang sama dapat diterapkan ke file properti. Mari edit file application.properties dan tambahkan satu kunci lagi:

greeting=Good morning

Setelah itu, kami akan memodifikasi HelloService untuk menggunakan properti baru kami:

@ConfigProperty(name = "greeting") private String greeting; public String politeHello(String name){ return greeting + " " + name; }

Jika kita menjalankan perintah curl yang sama , sekarang kita akan melihat:

Good morning Baeldung

Kami dapat dengan mudah mengemas aplikasi dengan menjalankan:

./mvnw package 

Ini akan menghasilkan 2 file jar di dalam direktori target :

  • quarkus-project-1.0-SNAPSHOT-runner.jar - jar yang dapat dieksekusi dengan dependensi yang disalin ke target / lib
  • quarkus-project-1.0-SNAPSHOT.jar - berisi kelas dan file sumber daya

Sekarang kita dapat menjalankan aplikasi terpaket:

java -jar target/quarkus-project-1.0-SNAPSHOT-runner.jar

5. Gambar Asli

Selanjutnya, kami akan menghasilkan gambar asli dari aplikasi kami. Gambar asli akan meningkatkan waktu mulai dan waktu untuk respons pertama. Dengan kata lain, ini berisi semua yang dibutuhkan untuk dijalankan, termasuk JVM minimal yang diperlukan untuk menjalankan aplikasi .

Untuk memulainya, kita perlu menginstal GraalVM dan variabel lingkungan GRAALVM_HOME dikonfigurasi.

Kami sekarang akan menghentikan aplikasi (Ctrl + C), jika belum dihentikan, dan menjalankan perintah:

./mvnw package -Pnative

Ini membutuhkan waktu beberapa detik untuk selesai. Karena gambar asli mencoba membuat semua kode AOT untuk boot lebih cepat, sebagai hasilnya, kita akan memiliki waktu pembuatan yang lebih lama.

We can run ./mvnw verify -Pnative to verify that our native artifact was properly constructed:

Secondly, we'll create a container image using our native executable. For that, we must have a container runtime (i.e. Docker) running in our machine. Let's open up a terminal window and execute:

./mvnw package -Pnative -Dnative-image.docker-build=true 

This will create a Linux 64-bit executable, therefore if we're using a different OS, it might not be runnable anymore. That's okay for now.

The project generation created a Dockerfile.native for us:

FROM registry.fedoraproject.org/fedora-minimal WORKDIR /work/ COPY target/*-runner /work/application RUN chmod 775 /work EXPOSE 8080 CMD ["./application", "-Dquarkus.http.host=0.0.0.0"] 

If we examine the file, we have a hint at what comes next. First, we'll create a docker image:

docker build -f src/main/docker/Dockerfile.native -t quarkus/quarkus-project .

Now, we can run the container using:

docker run -i --rm -p 8080:8080 quarkus/quarkus-project

The container started in an incredibly low time of 0.009s. That's one of the strengths of Quarkus.

Finally, we should test our modified REST to validate our application:

$ curl localhost:8080/hello/polite/Baeldung Good morning Baeldung

6. Deploying to OpenShift

Once we're done testing locally using Docker, we'll deploy our container to OpenShift. Assuming we have the Docker image on our registry, we can deploy the application following the steps below:

oc new-build --binary --name=quarkus-project -l app=quarkus-project oc patch bc/quarkus-project -p '{"spec":{"strategy":{"dockerStrategy":{"dockerfilePath":"src/main/docker/Dockerfile.native"}}}}' oc start-build quarkus-project --from-dir=. --follow oc new-app --image-stream=quarkus-project:latest oc expose service quarkus-project

Now, we can get the application URL by running:

oc get route

Lastly, we'll access the same endpoint (note that the URL might be different, depending on our IP address):

$ curl //quarkus-project-myproject.192.168.64.2.nip.io/hello/polite/Baeldung Good morning Baeldung

7. Conclusion

Dalam artikel ini, kami menunjukkan bahwa Quarkus adalah tambahan hebat yang dapat membawa Java ke cloud dengan lebih efektif. Misalnya, sekarang mungkin untuk membayangkan Java di AWS Lambda. Juga, Quarkus didasarkan pada standar seperti JPA dan JAX / RS. Oleh karena itu, kita tidak perlu mempelajari sesuatu yang baru.

Quarkus telah menarik banyak perhatian akhir-akhir ini, dan banyak fitur baru ditambahkan setiap hari. Ada beberapa proyek quickstart yang bisa kami coba Quarkus di repositori Quarkus GitHub.

Seperti biasa, kode untuk artikel ini tersedia di GitHub. Selamat membuat kode!