როგორ აერთიანებს Quarkus იმპერატიულ და რეაქტიულ პროგრამირებას

წელს ჩვენ ვგეგმავთ სერიოზულად განვავითაროთ კონტეინერის თემები, Cloud-Native Java и კუბერნეტები. ამ თემების ლოგიკური გაგრძელება იქნება ამბავი Quarkus-ის ჩარჩოზე, უკვე განიხილება ჰაბრეზე. დღევანდელი სტატია ნაკლებად ეხება „სუბატომური სუპერსწრაფი ჯავის“ დიზაინს და უფრო მეტად იმ დაპირებას, რომელიც Quarkus-ს ანიჭებს Enterprise-ს.

Java და JVM ჯერ კიდევ ძალიან პოპულარულია, მაგრამ სერვერის გარეშე ტექნოლოგიებთან და ღრუბლოვან მიკროსერვისებთან მუშაობისას, Java და სხვა JVM ენები სულ უფრო ნაკლებად გამოიყენება, რადგან ისინი ძალიან დიდ მეხსიერებას იკავებს და ძალიან ნელა იტვირთება, რაც მათ ხდის. ცუდად შეეფერება ხანმოკლე კონტეინერებთან გამოსაყენებლად. საბედნიეროდ, ეს სიტუაცია ახლა იწყებს ცვლილებას Quarkus-ის წყალობით.

სუპერსწრაფმა სუბატომურმა ჯავამ მიაღწია ახალ დონეს!

42 გამოშვება, 8 თვე საზოგადოებრივი მუშაობა და 177 საოცარი დეველოპერი - ამ ყველაფრის შედეგი იყო გამოშვება 2019 წლის ნოემბერში კვარკუსი 1.0, გამოცემა, რომელიც აღნიშნავს მნიშვნელოვან ეტაპს პროექტის განვითარებაში და გვთავაზობს უამრავ საინტერესო მახასიათებელს და შესაძლებლობებს (დაწვრილებით მათ შესახებ შეგიძლიათ წაიკითხოთ აქ განცხადება).

დღეს ჩვენ გაჩვენებთ, თუ როგორ აერთიანებს Quarkus იმპერატიულ და რეაქტიულ პროგრამირების მოდელებს ერთ რეაქტიულ ბირთვში. ჩვენ დავიწყებთ მოკლე ისტორიით და შემდეგ დეტალურად განვიხილავთ რა არის კვარკუსის რეაქტიული ბირთვის დუალიზმი და როგორ Java-დეველოპერებს შეუძლიათ ისარგებლონ ამ შეღავათებით.

მიკროსერვისები, მოვლენებზე ორიენტირებული არქიტექტურები и სერვერზე-ფუნქციები - ეს ყველაფერი, როგორც ამბობენ, დღეს მატულობს. ბოლო დროს ღრუბელზე ორიენტირებული არქიტექტურის შექმნა ბევრად უფრო ადვილი და ხელმისაწვდომი გახდა, მაგრამ პრობლემები რჩება - განსაკუთრებით ჯავის დეველოპერებისთვის. მაგალითად, სერვერის გარეშე ფუნქციებისა და მიკროსერვისების შემთხვევაში, საჭიროა სასწრაფოდ შემცირდეს გაშვების დრო, შემცირდეს მეხსიერების მოხმარება და მათი განვითარება კიდევ უფრო მოსახერხებელი და სასიამოვნო გახდეს. ჯავამ ბოლო წლებში რამდენიმე გაუმჯობესება მოახდინა, როგორიცაა კონტეინერების ერგონომიკის გაუმჯობესება და ა.შ. თუმცა, ჯავას კონტეინერში გამართულად მუშაობის მოპოვება ჯერ კიდევ რთულია. ასე რომ, ჩვენ დავიწყებთ Java-ს ზოგიერთი თანდაყოლილი სირთულეების განხილვით, რომლებიც განსაკუთრებით მწვავეა კონტეინერზე ორიენტირებული Java აპლიკაციების შემუშავებისას.

ჯერ ისტორიას გადავხედოთ.

ნაკადები და კონტეინერები

8u131 ვერსიით დაწყებული, ჯავამ დაიწყო მეტ-ნაკლებად კონტეინერების მხარდაჭერა ერგონომიკის ფუნქციონირების გაუმჯობესების გამო. კერძოდ, JVM-მა ახლა იცის, რამდენ პროცესორის ბირთვზე მუშაობს და შეუძლია დააკონფიგურიროს ძაფების აუზები — როგორც წესი, ჩანგალი/შეერთება აუზები — შესაბამისად. რა თქმა უნდა, ეს შესანიშნავია, მაგრამ ვთქვათ, გვაქვს ტრადიციული ვებ აპლიკაცია, რომელიც იყენებს HTTP სერლეტებს და მუშაობს Tomcat-ში, Jetty-ში და ა.შ. შედეგად, ეს აპლიკაცია თითოეულ მოთხოვნას მისცემს ცალკე თემას და საშუალებას მისცემს მას დაბლოკოს ეს თემა I/O ოპერაციების მოლოდინში, მაგალითად, მონაცემთა ბაზაში, ფაილებზე ან სხვა სერვისებზე წვდომისას. ანუ, ასეთი აპლიკაციის ზომა არ არის დამოკიდებული ხელმისაწვდომი ბირთვების რაოდენობაზე, არამედ ერთდროული მოთხოვნების რაოდენობაზე. გარდა ამისა, ეს ნიშნავს, რომ Kubernetes-ის კვოტები ან შეზღუდვები ბირთვების რაოდენობაზე აქ დიდად არ დაგვეხმარება და საქმე საბოლოოდ დამთავრდება.

მეხსიერების ამოწურვა

ძაფები მეხსიერებაა. და შიდა კონტეინერში მეხსიერების შეზღუდვა სულაც არ არის პანაცეა. უბრალოდ დაიწყეთ აპლიკაციების და ძაფების რაოდენობის გაზრდა და ადრე თუ გვიან შეხვდებით გადართვის სიხშირის კრიტიკულ ზრდას და, შედეგად, შესრულების დეგრადაციას. ასევე, თუ თქვენი აპლიკაცია იყენებს ტრადიციულ მიკროსერვისის ჩარჩოებს, ან უერთდება მონაცემთა ბაზას, ან იყენებს ქეშირებას, ან სხვაგვარად იყენებს მეხსიერებას, აშკარად გჭირდებათ ინსტრუმენტი, რომელიც საშუალებას მოგცემთ შეხედოთ JVM-ს და ნახოთ, როგორ მართავს ის მეხსიერებას მისი მოკვლის გარეშე. თავად JVM (მაგალითად, XX:+UseCGroupMemoryLimitForHeap). და მიუხედავად იმისა, რომ Java 9-ის შემდეგ JVM-მა ისწავლა cgroup-ების მიღება და შესაბამისად ადაპტირება, მეხსიერების დაჯავშნა და მართვა საკმაოდ რთულ საკითხად რჩება.

კვოტები და ლიმიტები

ჯავა 11-მა შემოიღო მხარდაჭერა CPU-ს კვოტებისთვის (მაგალითად, PreferContainerQuotaForCPUCount). Kubernetes ასევე გთავაზობთ ლიმიტებისა და კვოტების მხარდაჭერას. დიახ, ამ ყველაფერს აზრი აქვს, მაგრამ თუ აპლიკაცია კვლავ გადააჭარბებს გამოყოფილ კვოტას, ჩვენ კვლავ მივიღებთ ზომას - როგორც ეს ტრადიციული Java აპლიკაციების შემთხვევაში - განისაზღვრება ბირთვების რაოდენობით და თითოეულისთვის ცალკე ძაფით გამოყოფით. თხოვნა, მაშინ ამ ყველაფერს აზრი არ აქვს.
გარდა ამისა, თუ იყენებთ კვოტებს და ლიმიტებს ან Kubernetes-ის საფუძველში მყოფი პლატფორმის მასშტაბურ ფუნქციებს, პრობლემა ასევე თავისთავად არ მოგვარდება. ჩვენ უბრალოდ ვხარჯავთ უფრო მეტ რესურსს თავდაპირველი პრობლემის გადასაჭრელად ან საბოლოოდ ვხარჯავთ ზედმეტად. და თუ ეს არის მაღალი დატვირთვის სისტემა საჯარო საჯარო ღრუბელში, ჩვენ თითქმის რა თქმა უნდა ვიყენებთ იმაზე მეტ რესურსს, ვიდრე რეალურად გვჭირდება.

და რა ვუყოთ ამ ყველაფერს?

მარტივად რომ ვთქვათ, გამოიყენეთ ასინქრონული და დაუბლოკავი I/O ბიბლიოთეკები და ჩარჩოები, როგორიცაა Netty, ვერტ.x ან აკა. მათი რეაქტიული ხასიათის გამო ისინი ბევრად უკეთესად შეეფერებათ კონტეინერებში სამუშაოდ. I/O არა-დაბლოკვის წყალობით, ერთსა და იმავე თემას შეუძლია მრავალი ერთდროული მოთხოვნის დამუშავება. სანამ ერთი მოთხოვნა ელოდება I/O შედეგებს, ის ამუშავებს ძაფს და გადადის სხვა მოთხოვნით. და როდესაც I/O შედეგები საბოლოოდ ჩამოვა, პირველი მოთხოვნის დამუშავება გრძელდება. იმავე თემაში მოთხოვნის ურთიერთდამუშავებით, თქვენ შეგიძლიათ შეამციროთ ძაფების საერთო რაოდენობა და შეამციროთ რესურსების მოხმარება მოთხოვნების დამუშავებისთვის.

არაბლოკირებულ I/O-ში, ბირთვების რაოდენობა ხდება ძირითადი პარამეტრი, რადგან ის განსაზღვრავს I/O ძაფების რაოდენობას, რომლებიც შეიძლება შესრულდეს პარალელურად. სწორად გამოყენების შემთხვევაში, ეს საშუალებას გაძლევთ ეფექტურად გაანაწილოთ დატვირთვა ბირთვებს შორის და გაუმკლავდეთ უფრო დიდ დატვირთვას ნაკლები რესურსებით.

როგორ, სულ ეს არის?

არა, რაღაც სხვაა. რეაქტიული პროგრამირება ხელს უწყობს რესურსების უკეთ გამოყენებას, მაგრამ ასევე აქვს ფასი. კერძოდ, კოდი უნდა გადაიწეროს არადაბლოკვის პრინციპების შესაბამისად და თავიდან აიცილოთ I/O ძაფების დაბლოკვა. და ეს არის განვითარებისა და შესრულების სრულიად განსხვავებული მოდელი. და მიუხედავად იმისა, რომ აქ ბევრი სასარგებლო ბიბლიოთეკაა, ეს მაინც რადიკალური ცვლილებაა ჩვეულ აზროვნებაში.

პირველ რიგში, თქვენ უნდა ისწავლოთ როგორ დაწეროთ კოდი, რომელიც მუშაობს ასინქრონულად. მას შემდეგ რაც დაიწყებთ არადაბლოკვის I/O-ს გამოყენებას, თქვენ უნდა პირდაპირ მიუთითოთ რა უნდა მოხდეს მოთხოვნაზე პასუხის მიღებისას. უბრალოდ დაბლოკვა და ლოდინი აღარ იმუშავებს. ამის ნაცვლად, შეგიძლიათ გადაიტანოთ გამოძახებები, გამოიყენოთ რეაქტიული პროგრამირება ან გაგრძელება. მაგრამ ეს ყველაფერი არ არის: არადაბლოკვის I/O გამოსაყენებლად გჭირდებათ როგორც არადაბლოკვის სერვერები, ასევე კლიენტები, სასურველია ყველგან. HTTP-ის შემთხვევაში ყველაფერი მარტივია, მაგრამ ასევე არის მონაცემთა ბაზები, ფაილური სისტემები და მრავალი სხვა.

და მიუხედავად იმისა, რომ მთლიანი რეაქტიულობა ბოლოდან ბოლომდე ზრდის ეფექტურობას, ასეთი ცვლა პრაქტიკაში შეიძლება რთული იყოს. ამრიგად, რეაქტიული და იმპერატიული კოდების შერწყმის შესაძლებლობა ხდება წინაპირობა, რათა:

1. რესურსების ეფექტურად გამოყენება პროგრამული სისტემის ყველაზე დატვირთულ სფეროებში;
2. გამოიყენეთ უფრო მარტივი სტილის კოდი მის დანარჩენ ნაწილებში.

წარმოგიდგენთ Quarkus-ს

სინამდვილეში, ეს არის Quarkus-ის არსი - რეაქტიული და იმპერატიული მოდელების გაერთიანება ერთი გაშვების გარემოში.

Quarkus დაფუძნებულია Vert.x-სა და Netty-ზე, დეველოპერების დასახმარებლად რეაქტიული ჩარჩოებისა და გაფართოებების სპექტრით. Quarkus შექმნილია არა მხოლოდ HTTP მიკროსერვისების, არამედ მოვლენებზე ორიენტირებული არქიტექტურის შესაქმნელად. მისი რეაქტიული ხასიათის გამო, ის ძალიან ეფექტურად მუშაობს შეტყობინებების სისტემებთან (Apache Kafka, AMQP და ა.შ.).

ხრიკი არის ის, თუ როგორ გამოვიყენოთ იგივე რეაქტიული ძრავა, როგორც იმპერატიული, ასევე რეაქტიული კოდისთვის.

Quarkus ამას ბრწყინვალედ აკეთებს. არჩევანი იმპერატივსა და რეაქტიულს შორის აშკარაა - გამოიყენეთ რეაქტიული ბირთვი ორივესთვის. რაც ნამდვილად ეხმარება არის სწრაფი, დაუბლოკავი კოდი, რომელიც ამუშავებს თითქმის ყველაფერს, რაც გადის ღონისძიების მარყუჟის ძაფში, იგივე 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 პროექტის ვებსაიტი – quarkus.io
• Quarkus პროექტი GitHub-ზე – github.com/quarkusio/quarkus
• Quarkus პროექტი Twitter – twitter.com/QuarkusIO
• Quarkus პროექტის ჩატი - quarcusio.zulipchat.com
• Quarkus Project Forums – group.google.com/forum/#!ფორუმი/quarkus-dev

10 ვიდეო გაკვეთილი Quarkus-ზე თემის გასაცნობად

როგორც საიტზე წერენ Quarkus.io, კვარკუსი - რამდენად კუბერნეტები-ორიენტირებული Java სტეკი, მორგებული GraalVM და OpenJDK HotSpot-ისთვის და აწყობილი საუკეთესო Java ბიბლიოთეკებიდან და სტანდარტებიდან.

თემის გასაგებად, ჩვენ შევარჩიეთ 10 ვიდეო გაკვეთილი, რომელიც მოიცავს Quarkus-ის სხვადასხვა ასპექტს და მისი გამოყენების მაგალითებს:

1. წარმოგიდგენთ Quarkus: შემდეგი თაობის Java Framework კუბერნეტისთვის

თომას კვარნსტრომისა და ჯეისონ გრინის მიერ
Quarkus-ის პროექტის მიზანია შექმნას ჯავა პლატფორმა Kubernetes-ისთვის და სერვერის გარეშე გარემოსთვის და რეაქტიული და იმპერატიული პროგრამირების მოდელების გაერთიანება ერთ გაშვებულ გარემოში, რათა დეველოპერებმა მოქნილად შეცვალონ თავიანთი მიდგომა განაწილებული აპლიკაციების არქიტექტურის ფართო სპექტრთან მუშაობისას. შეიტყვეთ მეტი შესავალ ლექციაში ქვემოთ.

2. კვარკუსი: სუპერსწრაფი სუბატომიური ჯავა

ავტორი: ბურ სატერი
DevNation Live-ის ეს ვიდეო გაკვეთილი გვიჩვენებს, თუ როგორ გამოვიყენოთ Quarkus კორპორატიული Java აპლიკაციების, API-ების, მიკროსერვისების და სერვერის გარეშე ფუნქციების ოპტიმიზაციისთვის Kubernetes/OpenShift გარემოში, რაც მათ გაცილებით პატარას, სწრაფს და უფრო მასშტაბურს გახდის.

3. Quarkus და GraalVM: Hibernate-ის აჩქარება სუპერ სისწრაფემდე და მისი შემცირება სუბატომურ ზომებამდე

ავტორი: Sanne Grinovero
პრეზენტაციიდან შეიტყობთ, თუ როგორ გაჩნდა Quarkus, როგორ მუშაობს და როგორ გაძლევთ საშუალებას შექმნათ რთული ბიბლიოთეკები, როგორიცაა Hibernate ORM, თავსებადი GraalVM-ის მშობლიურ სურათებთან.

4. ისწავლეთ სერვერის გარეშე აპლიკაციების შემუშავება

ავტორი: მარტინ ლუთერი
ქვემოთ მოცემულ ვიდეოში ნაჩვენებია, თუ როგორ უნდა შექმნათ მარტივი Java აპლიკაცია Quarkus-ის გამოყენებით და განათავსოთ იგი სერვერის გარეშე პროგრამად Knative-ზე.

5. Quarkus: გაერთეთ კოდირებით

ავტორი: ედსონ იანაგა
ვიდეო გზამკვლევი თქვენი პირველი Quarkus პროექტის შესაქმნელად, რომელიც საშუალებას მოგცემთ გაიგოთ, რატომ იმარჯვებს Quarkus დეველოპერების გულებს.

6. ჯავა და კონტეინერები - როგორი იქნება მათი ერთობლივი მომავალი

გამოქვეყნებულია მარკ ლიტლის მიერ
ეს პრეზენტაცია წარმოგიდგენთ ჯავას ისტორიას და განმარტავს, თუ რატომ არის Quarkus ჯავის მომავალი.

7. კვარკუსი: სუპერსწრაფი სუბატომიური ჯავა

ავტორი: დიმიტრი ანდრეადისი
Quarkus-ის უპირატესობების მიმოხილვა, რომლებმაც მიიღეს აღიარება დეველოპერებისგან: სიმარტივე, ულტრა მაღალი სიჩქარე, საუკეთესო ბიბლიოთეკები და სტანდარტები.

8. კვარკუსი და სუბატომური სარაკეტო სისტემები

ავტორი: კლემენტ ესკოფიე
GraalVM-თან ინტეგრაციის მეშვეობით Quarkus უზრუნველყოფს ულტრა სწრაფი განვითარების გამოცდილებას და სუბატომურ გაშვების გარემოს. ავტორი საუბრობს Quarkus-ის რეაქტიულ მხარეზე და როგორ გამოვიყენოთ იგი რეაქტიული და ნაკადი აპლიკაციების შესაქმნელად.

9. Quarkus და სწრაფი აპლიკაციის განვითარება Eclipse MicroProfile-ში

ავტორი: ჯონ კლინგანი
Eclipse MicroProfile-ისა და Quarkus-ის კომბინაციით, დეველოპერებს შეუძლიათ შექმნან სრულფასოვანი კონტეინერირებული MicroProfile აპლიკაციები, რომლებიც ამოქმედდება ათობით მილიწამში. ვიდეო დეტალურად განიხილავს, თუ როგორ უნდა დააკოდიროს კონტეინერიზებული MicroProfile აპლიკაცია Kubernetes პლატფორმაზე განსათავსებლად.

10. ჯავა, "ტურბო" ვერსია

ავტორი: მარკუს ბილი
ავტორი გვიჩვენებს, თუ როგორ გამოვიყენოთ Quarkus სუპერ პატარა, სუპერ სწრაფი ჯავის კონტეინერების შესაქმნელად, რომლებიც რეალურ გარღვევას იძლევა, განსაკუთრებით სერვერების გარეშე გარემოში.

წყარო: www.habr.com