Quarkus ผสมผสานการเขียนโปรแกรมเชิงบังคับและเชิงโต้ตอบเข้าด้วยกันอย่างไร

ปีนี้เราวางแผนที่จะพัฒนาธีมคอนเทนเนอร์อย่างจริงจัง Java แบบคลาวด์เนทีฟ и Kubernetes. ความต่อเนื่องเชิงตรรกะของหัวข้อเหล่านี้จะเป็นเรื่องราวเกี่ยวกับกรอบงาน Quarkus อยู่แล้ว ที่พิจารณา ทางด้านฮาเบร บทความวันนี้ไม่เกี่ยวกับการออกแบบ "subatomic superfast Java" และเพิ่มเติมเกี่ยวกับคำมั่นสัญญาที่ Quarkus นำมาสู่ Enterprise

Java และ JVM ยังคงได้รับความนิยมอย่างมาก แต่เมื่อทำงานกับเทคโนโลยีไร้เซิร์ฟเวอร์และไมโครเซอร์วิสบนคลาวด์ ภาษา Java และภาษา JVM อื่นๆ จะถูกใช้น้อยลงเรื่อยๆ เนื่องจากใช้พื้นที่หน่วยความจำมากเกินไปและโหลดช้าเกินไป ส่งผลให้ ไม่เหมาะที่จะใช้กับภาชนะที่มีอายุสั้น โชคดีที่ตอนนี้สถานการณ์นี้เริ่มเปลี่ยนไปแล้ว ต้องขอบคุณ Quarkus

Superfast subatomic Java มาถึงระดับใหม่แล้ว!

42 รุ่น, 8 เดือนของการทำงานเพื่อชุมชนและนักพัฒนาที่น่าทึ่ง 177 คน - ผลลัพธ์ทั้งหมดคือการเปิดตัวในเดือนพฤศจิกายน 2019 ควาร์คัส 1.0ซึ่งเป็นการเปิดตัวที่ถือเป็นก้าวสำคัญในการพัฒนาโครงการและนำเสนอฟีเจอร์และความสามารถเจ๋งๆ มากมาย (คุณสามารถอ่านเพิ่มเติมเกี่ยวกับสิ่งเหล่านี้ได้ใน ประกาศ).

วันนี้เราจะแสดงให้คุณเห็นว่า Quarkus รวมโมเดลการเขียนโปรแกรมเชิงบังคับและเชิงโต้ตอบไว้ในแกนปฏิกิริยาเดียวได้อย่างไร เราจะเริ่มต้นด้วยประวัติโดยย่อ จากนั้นไปลงรายละเอียดว่าปฏิกิริยาคู่หลักปฏิกิริยาของ Quarkus คืออะไรและอย่างไร ชวา- นักพัฒนาสามารถใช้ประโยชน์จากสิทธิประโยชน์เหล่านี้ได้

ไมโครเซอร์วิส, สถาปัตยกรรมที่ขับเคลื่อนด้วยเหตุการณ์ и serverless-ฟังก์ชั่น - อย่างที่พวกเขาพูดกันทั้งหมดนี้กำลังเพิ่มขึ้นในปัจจุบัน เมื่อเร็ว ๆ นี้ การสร้างสถาปัตยกรรมที่เน้นระบบคลาวด์กลายเป็นเรื่องง่ายและเข้าถึงได้มากขึ้น แต่ปัญหายังคงอยู่ โดยเฉพาะอย่างยิ่งสำหรับนักพัฒนา Java ตัวอย่างเช่น ในกรณีของฟังก์ชันแบบไร้เซิร์ฟเวอร์และไมโครเซอร์วิส มีความจำเป็นเร่งด่วนในการลดเวลาเริ่มต้น ลดการใช้หน่วยความจำ และยังคงทำให้การพัฒนาสะดวกและสนุกสนานยิ่งขึ้น Java ได้ทำการปรับปรุงหลายอย่างในช่วงไม่กี่ปีที่ผ่านมา เช่น ปรับปรุงฟังก์ชันการยศาสตร์สำหรับคอนเทนเนอร์และอื่นๆ อย่างไรก็ตาม การทำให้ Java ทำงานอย่างถูกต้องในคอนเทนเนอร์ยังคงเป็นเรื่องที่ท้าทาย ดังนั้นเราจะเริ่มต้นด้วยการดูความซับซ้อนโดยธรรมชาติของ Java ซึ่งจะรุนแรงเป็นพิเศษเมื่อพัฒนาแอปพลิเคชัน Java เชิงคอนเทนเนอร์

ก่อนอื่นเรามาดูประวัติกันก่อน

สตรีมและคอนเทนเนอร์

เริ่มต้นด้วยเวอร์ชัน 8u131 Java เริ่มรองรับคอนเทนเนอร์ไม่มากก็น้อยเนื่องจากการปรับปรุงฟังก์ชันการยศาสตร์ โดยเฉพาะอย่างยิ่ง ตอนนี้ JVM รู้จำนวนแกนประมวลผลที่รันอยู่บนและสามารถกำหนดค่าเธรดพูลได้—โดยทั่วไปแล้วจะเป็นพูลแยก/รวม—ตามลำดับ แน่นอนว่านี่เป็นเรื่องดี แต่สมมติว่าเรามีเว็บแอปพลิเคชันแบบดั้งเดิมที่ใช้เซิร์ฟเล็ต HTTP และทำงานใน Tomcat, Jetty ฯลฯ ด้วยเหตุนี้ แอปพลิเคชันนี้จะให้แต่ละคำขอมีเธรดแยกกัน และอนุญาตให้บล็อกเธรดนี้ในขณะที่รอการดำเนินการ I/O เช่น เมื่อเข้าถึงฐานข้อมูล ไฟล์ หรือบริการอื่น ๆ นั่นคือขนาดของแอปพลิเคชันดังกล่าวไม่ได้ขึ้นอยู่กับจำนวนคอร์ที่มีอยู่ แต่ขึ้นอยู่กับจำนวนคำขอพร้อมกัน นอกจากนี้ ซึ่งหมายความว่าโควต้าหรือขีดจำกัดใน Kubernetes เกี่ยวกับจำนวนคอร์จะไม่ช่วยอะไรได้มากนักในที่นี้ และในที่สุดเรื่องนี้ก็จะจบลงด้วยการควบคุมปริมาณ

หน่วยความจำอ่อนล้า

กระทู้คือความทรงจำ และข้อจำกัดของหน่วยความจำภายในคอนเทนเนอร์ก็ไม่ใช่ยาครอบจักรวาลแต่อย่างใด เพียงเริ่มเพิ่มจำนวนแอปพลิเคชันและเธรด ไม่ช้าก็เร็วคุณจะพบกับความถี่ในการสลับที่เพิ่มขึ้นอย่างมาก และเป็นผลให้ประสิทธิภาพลดลง นอกจากนี้ หากแอปพลิเคชันของคุณใช้ไมโครเซอร์วิสเฟรมเวิร์กแบบดั้งเดิม หรือเชื่อมต่อกับฐานข้อมูล หรือใช้แคช หรือใช้หน่วยความจำมากเกินไป เห็นได้ชัดว่าคุณต้องการเครื่องมือที่ช่วยให้คุณดูภายใน JVM และดูวิธีที่มันจัดการหน่วยความจำโดยไม่ต้องฆ่ามัน JVM เอง (เช่น XX:+UseCGroupMemoryLimitForHeap) และถึงแม้ว่าตั้งแต่ Java 9 เป็นต้นมา JVM ได้เรียนรู้ที่จะยอมรับ cgroups และปรับเปลี่ยนตามนั้น การสำรองและการจัดการหน่วยความจำยังคงเป็นเรื่องที่ค่อนข้างซับซ้อน

โควต้าและขีดจำกัด

Java 11 แนะนำการรองรับโควต้า CPU (เช่น PreferContainerQuotaForCPUCount) Kubernetes ยังให้การสนับสนุนขีดจำกัดและโควต้าอีกด้วย ใช่ ทั้งหมดนี้สมเหตุสมผล แต่ถ้าแอปพลิเคชันเกินโควต้าที่จัดสรรอีกครั้ง เราก็จะได้ขนาดอีกครั้ง เช่นเดียวกับในกรณีของแอปพลิเคชัน Java แบบดั้งเดิม โดยพิจารณาจากจำนวนคอร์และด้วยการจัดสรรเธรดแยกกันสำหรับแต่ละเธรด ร้องขอแล้วมีความรู้สึกเพียงเล็กน้อยในทั้งหมดนี้
นอกจากนี้ หากคุณใช้โควต้าและขีดจำกัดหรือฟังก์ชันขยายขนาดของแพลตฟอร์มที่รองรับ Kubernetes ปัญหาก็ไม่สามารถแก้ไขได้ด้วยตัวมันเอง เราเพียงแต่ใช้ทรัพยากรมากขึ้นในการแก้ปัญหาเดิมหรือจบลงด้วยการใช้จ่ายเกินเหตุ และหากเป็นระบบที่มีภาระงานสูงในระบบคลาวด์สาธารณะ เราเกือบจะจบลงด้วยการใช้ทรัพยากรมากกว่าที่เราต้องการจริงๆ

และจะทำอย่างไรกับทั้งหมดนี้?

พูดง่ายๆ ก็คือใช้ไลบรารีและเฟรมเวิร์ก I/O แบบอะซิงโครนัสและไม่บล็อก เช่น Netty Vert.x หรืออักก้า เหมาะกว่ามากในการทำงานในตู้คอนเทนเนอร์เนื่องจากมีลักษณะเป็นปฏิกิริยา ขอบคุณ I/O ที่ไม่มีการบล็อก เธรดเดียวกันสามารถประมวลผลคำขอหลายรายการพร้อมกันได้ ในขณะที่คำขอหนึ่งกำลังรอผลลัพธ์ I/O การประมวลผลเธรดนั้นจะถูกรีลีสและเข้าครอบครองโดยคำขออื่น และเมื่อผลลัพธ์ I/O มาถึงในที่สุด การประมวลผลคำขอแรกจะดำเนินต่อไป ด้วยการประมวลผลคำขอแบบแทรกสลับภายในเธรดเดียวกัน คุณสามารถลดจำนวนเธรดทั้งหมดและลดการใช้ทรัพยากรสำหรับการประมวลผลคำขอได้

ด้วย I/O ที่ไม่มีการบล็อก จำนวนคอร์จะกลายเป็นพารามิเตอร์หลัก เนื่องจากเป็นตัวกำหนดจำนวนเธรด I/O ที่สามารถดำเนินการแบบขนานได้ เมื่อใช้อย่างถูกต้อง สิ่งนี้จะช่วยให้คุณกระจายโหลดระหว่างคอร์ได้อย่างมีประสิทธิภาพ และจัดการเวิร์กโหลดที่สูงขึ้นด้วยทรัพยากรน้อยลง

นั่นคือทั้งหมดอย่างไร?

ไม่ มีอย่างอื่นอีก การเขียนโปรแกรมแบบโต้ตอบช่วยให้ใช้ทรัพยากรได้ดีขึ้น แต่ก็มาพร้อมกับราคาเช่นกัน โดยเฉพาะอย่างยิ่งโค้ดจะต้องถูกเขียนใหม่ตามหลักการไม่บล็อกและหลีกเลี่ยงการบล็อกเธรด I/O และนี่คือรูปแบบการพัฒนาและการดำเนินการที่แตกต่างอย่างสิ้นเชิง และถึงแม้จะมีห้องสมุดที่มีประโยชน์มากมายที่นี่ แต่วิธีคิดปกติก็ยังคงเปลี่ยนแปลงไปอย่างสิ้นเชิง

ขั้นแรก คุณต้องเรียนรู้วิธีเขียนโค้ดที่ทำงานแบบอะซิงโครนัส เมื่อคุณเริ่มใช้ I/O ที่ไม่บล็อก คุณจะต้องระบุอย่างชัดเจนว่าควรเกิดอะไรขึ้นเมื่อได้รับการตอบกลับคำขอ การบล็อกและการรอเพียงอย่างเดียวจะไม่ทำงานอีกต่อไป แต่คุณสามารถส่งผ่านการโทรกลับ ใช้การเขียนโปรแกรมเชิงรับ หรือการดำเนินการต่อได้ แต่นั่นไม่ใช่ทั้งหมด: หากต้องการใช้ I/O ที่ไม่ปิดกั้น คุณต้องมีทั้งเซิร์ฟเวอร์และไคลเอนต์ที่ไม่ปิดกั้น โดยเฉพาะอย่างยิ่งทุกที่ ในกรณีของ HTTP ทุกอย่างเรียบง่าย แต่ก็มีฐานข้อมูล ระบบไฟล์ และอื่นๆ อีกมากมาย

และถึงแม้ว่าปฏิกิริยาจากต้นทางถึงปลายทางโดยรวมจะช่วยเพิ่มประสิทธิภาพสูงสุด แต่การเปลี่ยนแปลงดังกล่าวอาจทำได้ยากในทางปฏิบัติ ดังนั้น ความสามารถในการรวมโค้ดแบบโต้ตอบและโค้ดที่จำเป็นจึงกลายเป็นข้อกำหนดเบื้องต้นเพื่อ:

1. ใช้ทรัพยากรอย่างมีประสิทธิภาพในพื้นที่ที่มีการโหลดมากที่สุดของระบบซอฟต์แวร์
2. ใช้โค้ดสไตล์ที่เรียบง่ายกว่าในส่วนที่เหลือ

แนะนำควาร์ก

จริงๆ แล้ว นี่คือแก่นแท้ของ Quarkus - เพื่อรวมโมเดลเชิงโต้ตอบและความจำเป็นไว้ภายในสภาพแวดล้อมรันไทม์เดียว

Quarkus ใช้ Vert.x และ Netty พร้อมด้วยเฟรมเวิร์กและส่วนขยายแบบโต้ตอบมากมายที่ด้านบนเพื่อช่วยนักพัฒนา Quarkus ได้รับการออกแบบมาเพื่อสร้างไม่เพียงแต่ไมโครเซอร์วิส HTTP เท่านั้น แต่ยังรวมถึงสถาปัตยกรรมที่ขับเคลื่อนด้วยเหตุการณ์ด้วย เนื่องจากมีลักษณะเป็นปฏิกิริยา จึงทำงานได้อย่างมีประสิทธิภาพมากกับระบบการรับส่งข้อความ (Apache Kafka, AMQP ฯลฯ)

เคล็ดลับคือการใช้ Reactive Engine เดียวกันสำหรับทั้งโค้ดที่จำเป็นและโค้ดแบบโต้ตอบ

Quarkus ทำสิ่งนี้ได้อย่างยอดเยี่ยม ตัวเลือกระหว่างความจำเป็นและปฏิกิริยานั้นชัดเจน - ใช้เคอร์เนลปฏิกิริยาสำหรับทั้งสองอย่าง สิ่งที่ช่วยได้จริงๆ คือโค้ดที่รวดเร็วและไม่บล็อก ซึ่งจัดการเกือบทุกอย่างที่ส่งผ่านเธรด event-loop หรือที่เรียกว่าเธรด IO แต่ถ้าคุณมี REST แบบคลาสสิกหรือแอปพลิเคชันฝั่งไคลเอ็นต์ Quarkus ก็มีโมเดลการเขียนโปรแกรมที่จำเป็นพร้อมอยู่แล้ว ตัวอย่างเช่น การสนับสนุน HTTP ใน Quarkus ขึ้นอยู่กับการใช้เอ็นจิ้นที่ไม่มีการบล็อกและปฏิกิริยา (Eclipse Vert.x และ Netty) คำขอ HTTP ทั้งหมดที่ได้รับจากแอปพลิเคชันของคุณจะถูกส่งผ่านลูปเหตุการณ์ (IO Thread) ก่อน จากนั้นจึงส่งไปยังส่วนของโค้ดที่จัดการคำขอ ขึ้นอยู่กับปลายทาง รหัสการจัดการคำร้องขอสามารถเรียกภายในเธรดที่แยกจากกัน (ที่เรียกว่าเธรดผู้ปฏิบัติงาน ใช้ในกรณีของเซิร์ฟเล็ตและ Jax-RS) หรือใช้เธรด I/O ต้นทาง (เส้นทางที่โต้ตอบ)

ตัวเชื่อมต่อระบบข้อความใช้ไคลเอนต์ที่ไม่ปิดกั้นซึ่งทำงานอยู่ด้านบนของกลไก Vert.x ดังนั้น คุณจึงสามารถส่ง รับ และประมวลผลข้อความจากระบบมิดเดิลแวร์การส่งข้อความได้อย่างมีประสิทธิภาพ

เว็บไซต์ Quarkus.io ต่อไปนี้เป็นบทช่วยสอนที่ดีที่จะช่วยคุณเริ่มต้นใช้งาน Quarkus:

• การใช้เส้นทางปฏิกิริยา
• ไคลเอนต์ SQL เชิงโต้ตอบ
• การใช้ Apache Kafka กับการส่งข้อความโต้ตอบ
• การใช้ AMQP กับการส่งข้อความโต้ตอบ
• การใช้ Vertx API

นอกจากนี้เรายังได้สร้างบทช่วยสอนแบบลงมือปฏิบัติจริงแบบออนไลน์เพื่อสอนแง่มุมต่างๆ ของการเขียนโปรแกรมแบบโต้ตอบในเบราว์เซอร์ ไม่จำเป็นต้องใช้ IDE และไม่ต้องใช้คอมพิวเตอร์ คุณจะพบบทเรียนเหล่านี้ ที่นี่.

ทรัพยากรที่เป็นประโยชน์

• 4 เหตุผลที่ควรลองใช้ Quarkus
• เว็บไซต์โครงการ Quarkus – ควาร์คัส.io
• โครงการ Quarkus บน GitHub – github.com/quarkusio/quarkus
• โครงการ Quarkus Twitter – twitter.com/QuarkusIO
• การสนทนาโครงการ Quarkus – quarkusio.zulipchat.com
• ฟอรัมโครงการ Quarkus – groups.google.com/forum/#!forum/quarkus-dev

บทเรียนวิดีโอ 10 บทเรียนเกี่ยวกับ Quarkus เพื่อทำความคุ้นเคยกับหัวข้อนี้

อย่างที่พวกเขาพูดบนเว็บไซต์ Quarkus.io, ควาร์คัส - เป็น Kubernetes- Java stack ที่มุ่งเน้น ได้รับการปรับแต่งสำหรับ GraalVM และ OpenJDK HotSpot และประกอบจากไลบรารีและมาตรฐาน Java ที่ดีที่สุด

เพื่อช่วยให้คุณเข้าใจหัวข้อนี้ เราได้เลือกวิดีโอฝึกสอน 10 รายการที่ครอบคลุมแง่มุมต่างๆ ของ Quarkus และตัวอย่างการใช้งาน:

1. ขอแนะนำ Quarkus: Java Framework รุ่นต่อไปสำหรับ Kubernetes

โดย โธมัส ควาร์นสตรอม และ เจสัน กรีน
เป้าหมายของโครงการ Quarkus คือการสร้างแพลตฟอร์ม Java สำหรับ Kubernetes และสภาพแวดล้อมแบบไร้เซิร์ฟเวอร์ และเพื่อรวมโมเดลการเขียนโปรแกรมเชิงโต้ตอบและความจำเป็นไว้ในสภาพแวดล้อมรันไทม์เดียว เพื่อให้นักพัฒนาสามารถปรับเปลี่ยนแนวทางได้อย่างยืดหยุ่นเมื่อทำงานกับสถาปัตยกรรมแอปพลิเคชันแบบกระจายที่หลากหลาย ค้นหาข้อมูลเพิ่มเติมในการบรรยายเบื้องต้นด้านล่าง

2. Quarkus: Java Subatomic ที่เร็วสุด ๆ

โดย: เบอร์ ซัทเทอร์
วิดีโอบทช่วยสอนนี้จาก DevNation Live สาธิตวิธีใช้ Quarkus เพื่อเพิ่มประสิทธิภาพแอปพลิเคชัน Java ระดับองค์กร, API, ไมโครเซอร์วิส และฟังก์ชันแบบไร้เซิร์ฟเวอร์ในสภาพแวดล้อม Kubernetes/OpenShift ทำให้มีขนาดเล็กลง เร็วขึ้น และปรับขนาดได้มากขึ้น

3. Quarkus และ GraalVM: เร่ง Hibernate ให้เป็นความเร็วสูงสุดและลดขนาดลงเหลือขนาดที่ต่ำกว่าอะตอมมิก

ผู้เขียน : ซานเน กรีโนเวโร
จากการนำเสนอ คุณจะได้เรียนรู้ว่า Quarkus เกิดขึ้นได้อย่างไร มันทำงานอย่างไร และมันช่วยให้คุณสร้างไลบรารีที่ซับซ้อน เช่น Hibernate ORM ได้อย่างไร ซึ่งเข้ากันได้กับอิมเมจ GraalVM ดั้งเดิม

4. เรียนรู้การพัฒนาแอปพลิเคชันแบบไร้เซิร์ฟเวอร์

ผู้เขียน : มาร์ติน ลูเธอร์
วิดีโอด้านล่างแสดงวิธีสร้างแอปพลิเคชัน Java อย่างง่ายโดยใช้ Quarkus และปรับใช้เป็นแอปพลิเคชันแบบไร้เซิร์ฟเวอร์บน Knative

5. Quarkus: ขอให้สนุกกับการเขียนโค้ด

ผู้เขียน: เอ็ดสัน ยานากะ
วิดีโอแนะนำการสร้างโปรเจ็กต์ Quarkus แรกของคุณ ช่วยให้คุณเข้าใจว่าทำไม Quarkus ถึงชนะใจนักพัฒนา

6. Java และคอนเทนเนอร์ - อนาคตของพวกเขาจะเป็นอย่างไร

โพสต์โดย มาร์ค ลิตเติ้ล
การนำเสนอนี้จะแนะนำประวัติความเป็นมาของ Java และอธิบายว่าทำไม Quarkus จึงเป็นอนาคตของ Java

7. Quarkus: Java Subatomic ที่เร็วสุด ๆ

ผู้เขียน : ดิมิทริส แอนเดรียดิส
ภาพรวมข้อดีของ Quarkus ที่ได้รับการยอมรับจากนักพัฒนา: ความเรียบง่าย ความเร็วสูงพิเศษ ไลบรารี่และมาตรฐานที่ดีที่สุด

8. ระบบควาร์คัสและจรวดย่อยของอะตอม

ผู้เขียน : เคลมองต์ เอสคอฟฟีเยร์
ด้วยการผสานรวมกับ GraalVM Quarkus มอบประสบการณ์การพัฒนาที่รวดเร็วเป็นพิเศษและสภาพแวดล้อมรันไทม์ย่อยของอะตอม ผู้เขียนพูดถึงด้านปฏิกิริยาของ Quarkus และวิธีใช้เพื่อสร้างแอปพลิเคชันแบบโต้ตอบและสตรีมมิ่ง

9. Quarkus และการพัฒนาแอปพลิเคชั่นอย่างรวดเร็วใน Eclipse MicroProfile

ผู้เขียน : จอห์น คลิงแกน
ด้วยการรวม Eclipse MicroProfile และ Quarkus เข้าด้วยกัน นักพัฒนาจะสามารถสร้างแอปพลิเคชั่น MicroProfile ที่มีคุณสมบัติครบถ้วนในคอนเทนเนอร์ ซึ่งเปิดใช้งานได้ภายในเวลาสิบมิลลิวินาที วิดีโอนี้จะอธิบายรายละเอียดเกี่ยวกับวิธีเขียนโค้ดแอปพลิเคชัน MicroProfile แบบคอนเทนเนอร์สำหรับการปรับใช้บนแพลตฟอร์ม Kubernetes

10. Java เวอร์ชัน "เทอร์โบ"

ผู้เขียน : มาร์คัส บีล
ผู้เขียนแสดงวิธีใช้ Quarkus เพื่อสร้างคอนเทนเนอร์ Java ขนาดเล็กพิเศษและเร็วสุด ๆ ซึ่งช่วยให้เกิดความก้าวหน้าได้อย่างแท้จริง โดยเฉพาะในสภาพแวดล้อมแบบไร้เซิร์ฟเวอร์

ที่มา: will.com