Tahun ini kami merancang untuk membangunkan tema kontena secara serius, ΠΈ . Sambungan logik topik ini akan menjadi cerita tentang rangka kerja Quarkus, sudah pada HabrΓ©. Artikel hari ini kurang mengenai reka bentuk "Subatomic superfast Java" dan lebih lanjut mengenai janji yang Quarkus bawa kepada Enterprise.
Java dan JVM masih sangat popular, tetapi apabila bekerja dengan teknologi tanpa pelayan dan perkhidmatan mikro asli awan, Java dan bahasa JVM lain semakin kurang digunakan kerana mereka mengambil terlalu banyak ruang memori dan terlalu lambat untuk dimuatkan, menjadikannya kurang sesuai untuk digunakan dengan bekas jangka pendek. Nasib baik, keadaan ini kini mula berubah terima kasih kepada Quarkus.
Java subatom terpantas telah mencapai tahap baharu!
42 keluaran, 8 bulan kerja komuniti dan 177 pembangun yang hebat - hasil daripada semuanya ialah keluaran pada November 2019 , keluaran yang menandakan peristiwa penting dalam pembangunan projek dan menawarkan banyak ciri dan keupayaan yang hebat (anda boleh membaca lebih lanjut mengenainya dalam ).
Hari ini kami akan menunjukkan kepada anda cara Quarkus menggabungkan model pengaturcaraan imperatif dan reaktif menjadi satu teras reaktif. Kami akan bermula dengan sejarah ringkas dan kemudian pergi ke perincian tentang apakah dualisme teras reaktif Quarkus dan bagaimana -Pembangun boleh memanfaatkan faedah ini.
, ΠΈ -fungsi β semua ini, seperti yang mereka katakan, semakin meningkat hari ini. Baru-baru ini, penciptaan seni bina berpusatkan awan telah menjadi lebih mudah dan lebih mudah diakses, tetapi masalah kekal - terutamanya untuk pembangun Java. Sebagai contoh, dalam kes fungsi tanpa pelayan dan perkhidmatan mikro, terdapat keperluan mendesak untuk mengurangkan masa permulaan, mengurangkan penggunaan memori, dan masih menjadikan pembangunannya lebih mudah dan menyeronokkan. Java telah membuat beberapa penambahbaikan dalam beberapa tahun kebelakangan ini, seperti fungsi ergonomik yang lebih baik untuk bekas dan sebagainya. Walau bagaimanapun, mendapatkan Java untuk berfungsi dengan betul dalam bekas masih mencabar. Oleh itu, kita akan mulakan dengan melihat beberapa kerumitan yang wujud dalam Java, yang sangat teruk apabila membangunkan aplikasi Java berorientasikan kontena.
Pertama, mari kita lihat sejarah.
Aliran dan bekas
Bermula dengan versi 8u131, Java mula menyokong lebih kurang bekas kerana penambahbaikan dalam fungsi ergonomik. Khususnya, JVM kini mengetahui berapa banyak teras pemproses yang sedang dijalankan dan boleh mengkonfigurasi kumpulan benangβbiasanya fork/join poolβmengikutnya. Sudah tentu, ini bagus, tetapi katakan kami mempunyai aplikasi web tradisional yang menggunakan servlet HTTP dan berjalan di Tomcat, Jetty, dsb. Akibatnya, aplikasi ini akan memberikan setiap permintaan urutan berasingan dan membenarkannya menyekat utas ini sementara menunggu operasi I/O, contohnya, apabila mengakses pangkalan data, fail atau perkhidmatan lain. Iaitu, saiz aplikasi sedemikian tidak bergantung pada bilangan teras yang tersedia, tetapi pada bilangan permintaan serentak. Di samping itu, ini bermakna bahawa kuota atau had dalam Kubernetes pada bilangan teras tidak akan banyak membantu di sini, dan perkara itu akhirnya akan berakhir dengan pendikit.
Keletihan ingatan
Benang adalah ingatan. Dan had memori dalam bekas sama sekali bukan ubat penawar. Hanya mula menambah bilangan aplikasi dan urutan, dan lambat laun anda akan menghadapi peningkatan kritikal dalam kekerapan pensuisan dan, akibatnya, kemerosotan prestasi. Selain itu, jika aplikasi anda menggunakan rangka kerja mikroperkhidmatan tradisional, atau menyambung ke pangkalan data, atau menggunakan caching, atau sebaliknya menggunakan memori, anda jelas memerlukan alat yang membolehkan anda melihat ke dalam JVM dan melihat cara ia mengurus memori tanpa membunuhnya. JVM sendiri (contohnya, XX:+UseCGroupMemoryLimitForHeap). Dan walaupun, sejak Java 9, JVM telah belajar untuk menerima cgroup dan menyesuaikan diri dengan sewajarnya, menempah dan mengurus memori kekal sebagai perkara yang agak rumit.
Kuota dan had
Java 11 memperkenalkan sokongan untuk kuota CPU (seperti PreferContainerQuotaForCPUCount). Kubernetes juga menawarkan sokongan untuk had dan kuota. Ya, ini semua masuk akal, tetapi jika aplikasi sekali lagi melebihi kuota yang diperuntukkan, kita sekali lagi akan mendapat saiz - seperti halnya dengan aplikasi Java tradisional - ditentukan oleh bilangan teras dan dengan peruntukan benang berasingan untuk setiap permintaan, maka ada sedikit akal dalam semua ini.
Selain itu, jika anda menggunakan kuota dan had atau fungsi skala keluar platform yang mendasari Kubernetes, masalah itu juga tidak dapat diselesaikan dengan sendirinya. Kami hanya membelanjakan lebih banyak sumber untuk menyelesaikan masalah asal atau akhirnya berbelanja berlebihan. Dan jika ia adalah sistem beban tinggi dalam awan awam awam, kita hampir pasti akan menggunakan lebih banyak sumber daripada yang kita perlukan.
Dan apa yang perlu dilakukan dengan semua ini?
Secara ringkasnya, gunakan perpustakaan dan rangka kerja I/O tak segerak dan tidak menyekat seperti Netty, atau Akka. Mereka lebih sesuai untuk bekerja dalam bekas kerana sifat reaktifnya. Terima kasih kepada I/O yang tidak menyekat, urutan yang sama boleh memproses berbilang permintaan serentak. Semasa satu permintaan sedang menunggu keputusan I/O, pemprosesan benang itu dikeluarkan dan diambil alih oleh permintaan lain. Dan apabila keputusan I/O akhirnya tiba, pemprosesan permintaan pertama diteruskan. Dengan pemprosesan permintaan bersilang dalam urutan yang sama, anda boleh mengurangkan jumlah bilangan utas dan mengurangkan penggunaan sumber untuk memproses permintaan.
Dengan I/O yang tidak menyekat, bilangan teras menjadi parameter utama kerana ia menentukan bilangan utas I/O yang boleh dilaksanakan secara selari. Apabila digunakan dengan betul, ini membolehkan anda mengagihkan beban antara teras dengan berkesan dan mengendalikan beban kerja yang lebih tinggi dengan sumber yang lebih sedikit.
Bagaimana, itu sahaja?
Tidak, ada sesuatu yang lain. Pengaturcaraan reaktif membantu menggunakan sumber dengan lebih baik, tetapi juga pada harga yang berpatutan. Khususnya, kod tersebut perlu ditulis semula mengikut prinsip tidak menyekat dan mengelak daripada menyekat benang I/O. Dan ini adalah model pembangunan dan pelaksanaan yang sama sekali berbeza. Dan walaupun terdapat banyak perpustakaan berguna di sini, ia masih merupakan perubahan radikal dalam cara pemikiran biasa.
Pertama, anda perlu belajar cara menulis kod yang berjalan secara tidak segerak. Sebaik sahaja anda mula menggunakan I/O yang tidak menyekat, anda perlu menyatakan dengan jelas perkara yang harus berlaku apabila respons kepada permintaan diterima. Hanya menyekat dan menunggu tidak akan berfungsi lagi. Sebaliknya, anda boleh menghantar panggilan balik, menggunakan pengaturcaraan reaktif atau kesinambungan. Tetapi bukan itu sahaja: untuk menggunakan I/O yang tidak menyekat, anda memerlukan kedua-dua pelayan dan pelanggan yang tidak menyekat, sebaik-baiknya di mana-mana sahaja. Dalam kes HTTP, semuanya mudah, tetapi terdapat juga pangkalan data, sistem fail dan banyak lagi.
Dan walaupun jumlah kereaktifan hujung ke hujung memaksimumkan kecekapan, peralihan sebegitu sukar untuk dipraktikkan. Oleh itu, keupayaan untuk menggabungkan kod reaktif dan imperatif menjadi prasyarat untuk:
- Menggunakan sumber secara berkesan dalam kawasan yang paling banyak dimuatkan dalam sistem perisian;
- Gunakan kod gaya yang lebih mudah dalam bahagian yang tinggal.
Memperkenalkan Quarkus
Sebenarnya, ini adalah intipati Quarkus - untuk menggabungkan model reaktif dan penting dalam persekitaran masa jalan tunggal.
Quarkus adalah berdasarkan Vert.x dan Netty, dengan rangkaian rangka kerja dan sambungan reaktif di atas untuk membantu pembangun. Quarkus direka bentuk untuk membina bukan sahaja perkhidmatan mikro HTTP, tetapi juga seni bina dipacu peristiwa. Oleh kerana sifatnya yang reaktif, ia berfungsi dengan sangat berkesan dengan sistem pemesejan (Apache Kafka, AMQP, dll.).
Caranya ialah cara menggunakan enjin reaktif yang sama untuk kod imperatif dan reaktif.
Quarkus melakukan ini dengan cemerlang. Pilihan antara imperatif dan reaktif adalah jelas - gunakan kernel reaktif untuk kedua-duanya. Perkara yang benar-benar membantunya ialah kod yang pantas dan tidak menyekat yang mengendalikan hampir semua perkara yang melalui utas gelung peristiwa, aka benang IO. Tetapi jika anda mempunyai REST klasik atau aplikasi sisi klien, Quarkus mempunyai model pengaturcaraan penting yang sedia. Contohnya, sokongan HTTP dalam Quarkus adalah berdasarkan penggunaan enjin tidak menyekat dan reaktif (Eclipse Vert.x dan Netty). Semua permintaan HTTP yang diterima oleh aplikasi anda mula-mula melalui gelung peristiwa (Io Thread) dan kemudian dihantar ke bahagian kod yang mengurus permintaan. Bergantung pada destinasi, kod pengurusan permintaan boleh dipanggil dalam benang berasingan (yang dipanggil benang pekerja, digunakan dalam kes servlet dan Jax-RS) atau menggunakan benang I/O sumber (laluan reaktif).
Penyambung sistem pemesejan menggunakan klien tidak menyekat yang berjalan di atas enjin Vert.x. Oleh itu, anda boleh menghantar, menerima dan memproses mesej dengan berkesan daripada sistem perisian tengah pemesejan.
Laman web ini Berikut ialah beberapa tutorial yang baik untuk membantu anda bermula dengan Quarkus:
Kami juga telah mencipta tutorial praktikal dalam talian untuk mengajar anda pelbagai aspek pengaturcaraan reaktif hanya dalam penyemak imbas, tiada IDE diperlukan dan komputer tidak diperlukan. Anda boleh mencari pelajaran ini .
Sumber Berguna
- Laman web projek Quarkus -
- Projek Quarkus di GitHub -
- Projek Quarkus Twitter -
- Sembang projek Quarkus -
- Forum Projek Quarkus β !forum/quarkus-dev
10 pelajaran video tentang Quarkus untuk membiasakan diri dengan topik tersebut
Seperti yang mereka katakan di laman web , - Adakah -Timbunan Java berorientasikan, disesuaikan untuk GraalVM dan OpenJDK HotSpot dan dipasang daripada perpustakaan dan piawaian Java terbaik.
Untuk membantu anda memahami topik tersebut, kami telah memilih 10 tutorial video yang merangkumi pelbagai aspek Quarkus dan contoh penggunaannya:
1. Memperkenalkan Quarkus: Rangka Kerja Java Generasi Seterusnya untuk Kubernetes
Oleh Thomas Qvarnstrom dan Jason Greene
Matlamat projek Quarkus adalah untuk mencipta platform Java untuk Kubernetes dan persekitaran tanpa pelayan, dan untuk menggabungkan model pengaturcaraan reaktif dan penting ke dalam satu persekitaran masa jalan supaya pembangun boleh mengubah pendekatan mereka secara fleksibel apabila bekerja dengan pelbagai seni bina aplikasi yang diedarkan. Ketahui lebih lanjut dalam syarahan pengenalan di bawah.
2. Quarkus: Superfast Subatomic Java
Oleh: Burr Sutter
Tutorial video daripada DevNation Live ini menunjukkan cara menggunakan Quarkus untuk mengoptimumkan aplikasi Java perusahaan, API, perkhidmatan mikro dan fungsi tanpa pelayan dalam persekitaran Kubernetes/OpenShift, menjadikannya lebih kecil, lebih pantas dan lebih berskala.
3. Quarkus dan GraalVM: mempercepatkan Hibernate kepada kelajuan super dan mengecilkannya kepada saiz subatom
Pengarang: Sanne Grinovo
Daripada pembentangan, anda akan belajar bagaimana Quarkus muncul, cara ia berfungsi dan cara ia membolehkan anda membuat perpustakaan yang kompleks, seperti Hibernate ORM, serasi dengan imej GraalVM asli.
4. Belajar untuk membangunkan aplikasi tanpa pelayan
Pengarang: Martin Luther
Video di bawah menunjukkan cara untuk mencipta aplikasi Java mudah menggunakan Quarkus dan menggunakan ia sebagai aplikasi tanpa pelayan di Knative.
5. Quarkus: Selamat mengekod
Pengarang: Edson Yanaga
Panduan video untuk mencipta projek Quarkus pertama anda, membolehkan anda memahami sebab Quarkus memenangi hati pembangun.
6. Java dan bekas - apakah masa depan mereka bersama
Dihantar oleh Mark Little
Pembentangan ini memperkenalkan sejarah Java dan menerangkan mengapa Quarkus adalah masa depan Java.
7. Quarkus: Superfast Subatomic Java
Pengarang: Dimitris Andreadis
Gambaran keseluruhan kelebihan Quarkus yang telah menerima pengiktirafan daripada pembangun: kesederhanaan, kelajuan ultra tinggi, perpustakaan dan piawaian terbaik.
8. Sistem roket Quarkus dan subatomik
Pengarang: Clement Escoffier
Melalui penyepaduan dengan GraalVM, Quarkus menyediakan pengalaman pembangunan yang sangat pantas dan persekitaran masa jalan subatomik. Penulis bercakap tentang bahagian reaktif Quarkus dan cara menggunakannya untuk membina aplikasi reaktif dan penstriman.
9. Quarkus dan pembangunan aplikasi pesat dalam Eclipse MicroProfile
Pengarang: John Clingan
Dengan menggabungkan Eclipse MicroProfile dan Quarkus, pembangun boleh mencipta aplikasi MicroProfile kontena berciri penuh yang dilancarkan dalam berpuluh-puluh milisaat. Video ini menerangkan secara terperinci tentang cara mengodkan aplikasi MicroProfile dalam bekas untuk penggunaan pada platform Kubernetes.
10. Java, versi "Turbo".
Pengarang: Marcus Biel
Pengarang menunjukkan cara menggunakan Quarkus untuk mencipta bekas Java yang sangat kecil dan sangat laju yang membolehkan penemuan sebenar, terutamanya dalam persekitaran tanpa pelayan.
Sumber: www.habr.com