כיצד Quarkus משלב תכנות חובה ותגובתי

השנה אנחנו מתכננים לפתח ברצינות נושאי מיכל, Java מקורית בענן и קוברנט. המשך הגיוני של הנושאים האלה יהיה כבר סיפור על מסגרת Quarkus נחשב על האברה. המאמר של היום עוסק פחות בעיצוב של "ג'אווה סופר-מהירה תת-אטומית" ויותר על ההבטחה שקווארקוס מביא לאנטרפרייז.

Java וה-JVM עדיין פופולריים מאוד, אבל כשעובדים עם טכנולוגיות ללא שרתים ומיקרו-שירותים מקוריים בענן, נעשה שימוש פחות ופחות ב-Java ושפות JVM אחרות מכיוון שהן תופסות יותר מדי שטח זיכרון ואיטיות מדי לטעינה, מה שהופך אותן לא מתאים לשימוש עם מיכלים קצרי מועד. למרבה המזל, המצב הזה מתחיל כעת להשתנות הודות לקווארקוס.

ג'אווה תת-אטומית מהירה במיוחד הגיעה לרמה חדשה!

42 מהדורות, 8 חודשים של עבודה קהילתית ו-177 מפתחים מדהימים - התוצאה של הכל הייתה השחרור בנובמבר 2019 קווארקוס 1.0, מהדורה שמסמנת אבן דרך חשובה בפיתוח הפרויקט ומציעה הרבה פיצ'רים ויכולות מגניבות (תוכלו לקרוא עליהן עוד ב הַכרָזָה).

היום נראה לכם כיצד Quarkus משלב מודלים של תכנות חיוניים ותגובתיים לליבה תגובתית אחת. נתחיל בהיסטוריה קצרה ולאחר מכן נפרט מהו הדואליזם התגובתי של קווארקוס וכיצד Java-מפתחים יכולים לנצל את ההטבות הללו.

שירותי מיקרו, ארכיטקטורות מונעות אירועים и ללא שרת-פונקציות - כל זה, כמו שאומרים, היום בעלייה. לאחרונה, היצירה של ארכיטקטורות ממוקדות בענן הפכה להרבה יותר קלה ונגישה, אך נותרו בעיות - במיוחד עבור מפתחי Java. לדוגמה, במקרה של פונקציות ללא שרתים ומיקרו-שירותים, יש צורך דחוף לצמצם את זמן האתחול, להפחית את צריכת הזיכרון, ועדיין להפוך את הפיתוח שלהם לנוח ומהנה יותר. ג'אווה ביצעה מספר שיפורים בשנים האחרונות, כגון שיפור בפונקציונליות הארגונומיה עבור מכולות וכן הלאה. עם זאת, לגרום ל-Java לעבוד כמו שצריך במיכל עדיין מאתגר. אז נתחיל בהסתכלות על כמה מהמורכבויות הטבועות ב-Java, שהן חריפות במיוחד בעת פיתוח יישומי Java מוכווני מיכל.

ראשית, בואו נסתכל על ההיסטוריה.

נחלים ומיכלים

החל מגרסה 8u131, Java החלה לתמוך פחות או יותר במכולות עקב שיפורים בפונקציונליות הארגונומיה. בפרט, ה-JVM יודע כעת על כמה ליבות מעבד הוא פועל ויכול להגדיר בריכות חוטים - בדרך כלל בריכות מזלג/חיבור - בהתאם. כמובן שזה נהדר, אבל נניח שיש לנו אפליקציית אינטרנט מסורתית שמשתמשת בשרתים של HTTP ופועלת ב- Tomcat, Jetty וכו'. כתוצאה מכך, אפליקציה זו תיתן לכל בקשה שרשור נפרד ותאפשר לה לחסום את השרשור הזה בזמן המתנה לפעולות קלט/פלט, למשל, בעת גישה למסד הנתונים, לקבצים או לשירותים אחרים. כלומר, הגודל של אפליקציה כזו אינו תלוי במספר הליבות הזמינות, אלא במספר הבקשות בו-זמנית. בנוסף, זה אומר שמכסות או הגבלות ב-Kubernetes על מספר הליבות לא יעזרו כאן הרבה, והעניין בסופו של דבר יסתיים במצערת.

תשישות זיכרון

חוטים הם זיכרון. ומגבלות זיכרון תוך-מכל אינן בשום פנים ואופן תרופת פלא. פשוט התחל להגדיל את מספר היישומים והשרשורים, ובמוקדם או במאוחר תיתקל בעלייה קריטית בתדירות המיתוג וכתוצאה מכך, ירידה בביצועים. כמו כן, אם האפליקציה שלך משתמשת במסגרות מיקרו-שירות מסורתיות, או מתחברת למסד נתונים, או משתמשת במטמון, או משתמשת בכל דרך אחרת בזיכרון, ברור שאתה צריך כלי שמאפשר לך להסתכל בתוך ה-JVM ולראות כיצד הוא מנהל את הזיכרון מבלי להרוג אותו. JVM עצמו (לדוגמה, XX:+UseCGroupMemoryLimitForHeap). ולמרות שמאז Java 9, ה-JVM למד לקבל cgroups ולהסתגל בהתאם, שמירת וניהול הזיכרון נותרו עניין מורכב למדי.

מכסות ומגבלות

Java 11 הציגה תמיכה במכסות CPU (כמו PreferContainerQuotaForCPUCount). Kubernetes מציעה גם תמיכה במגבלות ומכסות. כן, כל זה הגיוני, אבל אם האפליקציה שוב חורגת מהמכסה שהוקצתה, בסופו של דבר נקבל את הגודל - כפי שקורה ביישומי Java מסורתיים - שנקבע לפי מספר הליבות ועם הקצאת שרשור נפרד לכל אחת מהן. בקשה, אז אין טעם בכל זה.
בנוסף, אם אתה משתמש במכסות ומגבלות או בפונקציות ה-scale-out של הפלטפורמה שבבסיס Kubernetes, הבעיה גם לא נפתרת מעצמה. אנחנו פשוט מבזבזים יותר משאבים בפתרון הבעיה המקורית או בסופו של דבר מוציאים יותר מדי. ואם מדובר במערכת בעומס גבוה בענן ציבורי, כמעט בטוח שבסופו של דבר אנחנו משתמשים ביותר משאבים ממה שאנחנו באמת צריכים.

ומה לעשות עם כל זה?

במילים פשוטות, השתמש בספריות קלט/פלט ובמסגרות אסינכרוניות ולא חוסמות כמו Netty, Vert.x או אקה. הם מתאימים הרבה יותר לעבודה במיכלים בשל האופי התגובתי שלהם. הודות ל-I/O לא חוסם, אותו שרשור יכול לעבד מספר בקשות בו-זמנית. בעוד בקשה אחת ממתינה לתוצאות קלט/פלט, השרשור המעבד אותה משוחרר ומשתלט על ידי בקשה אחרת. וכאשר תוצאות הקלט/פלט מגיעות סוף סוף, עיבוד הבקשה הראשונה ממשיך. על ידי עיבוד שזור של בקשות בתוך אותו שרשור, אתה יכול להפחית את המספר הכולל של השרשורים ולהפחית את צריכת המשאבים לעיבוד בקשות.

עם קלט/פלט לא חוסם, מספר הליבות הופך לפרמטר מפתח מכיוון שהוא קובע את מספר פתילי הקלט/פלט שניתן לבצע במקביל. בשימוש נכון, זה מאפשר לך לפזר ביעילות את העומס בין הליבות ולטפל בעומסי עבודה גבוהים יותר עם פחות משאבים.

איך, זה הכל?

לא, יש משהו אחר. תכנות ריאקטיבי עוזר לנצל טוב יותר את המשאבים, אך גם גובה מחיר. בפרט, יהיה צורך לשכתב את הקוד לפי עקרונות אי החסימה ולהימנע מחסימת שרשורי I/O. וזהו מודל אחר לגמרי של פיתוח וביצוע. ולמרות שיש כאן הרבה ספריות שימושיות, עדיין מדובר בשינוי קיצוני בדרך החשיבה הרגילה.

ראשית, עליך ללמוד כיצד לכתוב קוד שפועל באופן אסינכרוני. ברגע שתתחיל להשתמש ב-I/O לא חוסם, עליך לציין במפורש מה צריך לקרות כאשר מתקבלת תגובה לבקשה. פשוט לחסום ולהמתין כבר לא יעבוד. במקום זאת, אתה יכול להעביר התקשרויות חוזרות, להשתמש בתכנות ריאקטיבי או המשך. אבל זה לא הכל: כדי להשתמש ב-I/O לא חוסם, צריך גם שרתים וגם לקוחות לא חוסמים, רצוי בכל מקום. במקרה של HTTP הכל פשוט, אבל יש גם מסדי נתונים, מערכות קבצים ועוד הרבה.

ולמרות שתגובתיות מוחלטת מקצה לקצה ממקסמת את היעילות, שינוי כזה יכול להיות קשה לעיכול בפועל. לכן, היכולת לשלב קוד תגובתי וקוד ציווי הופכת לתנאי מוקדם על מנת:

1. השתמש ביעילות במשאבים באזורים הטעונים ביותר של מערכת התוכנה;
2. השתמש בקוד סגנון פשוט יותר בחלקים הנותרים שלו.

היכרות עם קווארקוס

למעשה, זו המהות של Quarkus - לשלב מודלים תגובתיים והכרחיים בתוך סביבת זמן ריצה אחת.

Quarkus מבוסס על Vert.x ו-Netty, עם מגוון מסגרות והרחבות ריאקטיביות למעלה כדי לעזור למפתח. Quarkus מיועד לבניית לא רק שירותי מיקרו HTTP, אלא גם ארכיטקטורות מונעות אירועים. בשל אופיו התגובתי, הוא עובד ביעילות רבה עם מערכות העברת הודעות (Apache Kafka, AMQP וכו').

החוכמה היא כיצד להשתמש באותו מנוע תגובתי עבור קוד ציווי ותגובתי כאחד.

קווארקוס עושה זאת בצורה מבריקה. הבחירה בין ציווי לתגובתי ברורה - השתמשו בקרנל תגובתי עבור שניהם. מה שזה באמת עוזר בו הוא קוד מהיר ולא חוסם שמטפל כמעט בכל מה שעובר בשרשור לולאת האירועים, הלא הוא IO thread. אבל אם יש לך REST קלאסי או יישומי צד לקוח, ל-Quarkus יש מודל תכנות חיוני מוכן. לדוגמה, תמיכת HTTP ב-Quarkus מבוססת על שימוש במנוע לא חוסם ותגובתי (Eclipse Vert.x ו-Netty). כל בקשות ה-HTTP המתקבלות על ידי האפליקציה שלך מועברות תחילה דרך לולאת אירוע (IO Thread) ולאחר מכן נשלחות לחלק של הקוד שמנהל את הבקשות. בהתאם ליעד, ניתן לקרוא לקוד ניהול הבקשות בתוך שרשור נפרד (מה שנקרא worker thread, המשמש במקרה של servlets ו-Jax-RS) או להשתמש בשרשור ה-I/O של המקור (מסלול תגובתי).

מחברי מערכת הודעות משתמשים בלקוחות שאינם חוסמים הפועלים על גבי מנוע Vert.x. לכן, אתה יכול לשלוח, לקבל ולעבד הודעות ביעילות ממערכות תוכנת העברת הודעות.

האתר Quarkus.io הנה כמה מדריכים טובים שיעזרו לך להתחיל בעבודה עם Quarkus:

• שימוש בנתיבים ריאקטיביים
• לקוחות SQL ריאקטיביים
• שימוש באפאצ'י קפקא עם הודעות ריאקטיביות
• שימוש ב-AMQP עם הודעות ריאקטיביות
• שימוש ב-Vertx API

יצרנו גם מדריכי לימוד מקוונים כדי ללמד אותך היבטים שונים של תכנות ריאקטיבי בדפדפן בלבד, ללא צורך ב-IDE וללא צורך במחשב. אתה יכול למצוא שיעורים אלה כאן.

משאבים מועילים

• 4 סיבות לנסות את Quarkus
• אתר פרויקט Quarkus – quarkus.io
• פרויקט Quarkus ב-GitHub - github.com/quarkusio/quarkus
• פרויקט Quarkus Twitter - twitter.com/QuarkusIO
• צ'אט פרויקט Quarkus - quarkusio.zulipchat.com
• פורומים של פרויקט קווקוס - groups.google.com/forum/#!forum/quarkus-dev

10 שיעורי וידאו על Quarkus כדי להכיר את הנושא

כמו שאומרים באתר Quarkus.io, קוורקוס - זה קוברנטערימת Java מכוונת, מותאמת עבור GraalVM ו-OpenJDK HotSpot והורכבה מהספריות והסטנדרטים הטובים ביותר של Java.

כדי לעזור לך להבין את הנושא, בחרנו 10 מדריכי וידאו המכסים היבטים שונים של Quarkus ודוגמאות לשימוש בו:

1. היכרות עם Quarkus: The Next Generation Java Framework עבור Kubernetes

מאת תומאס קוורנסטרום וג'ייסון גרין
המטרה של פרויקט Quarkus היא ליצור פלטפורמת Java עבור Kubernetes וסביבות ללא שרתים, ולשלב מודלים של תכנות ריאקטיביים וחיוניים לסביבת זמן ריצה אחת, כך שמפתחים יוכלו לגוון בגמישות את הגישה שלהם כאשר הם עובדים עם מגוון רחב של ארכיטקטורות יישומים מבוזרות. למידע נוסף בהרצאת המבוא למטה.

2. Quarkus: Java Subatomic Superfast

מאת: בור סאטר
מדריך וידאו זה מבית DevNation Live מדגים כיצד להשתמש ב-Quarkus כדי לייעל יישומי Java, ממשקי API, מיקרו-שירותים ופונקציות ללא שרת בסביבת Kubernetes/OpenShift, מה שהופך אותם להרבה יותר קטנים, מהירים וניתנים להרחבה.

3. Quarkus ו-GraalVM: האצת Hibernate למהירויות סופר וכיווץ אותו לגדלים תת-אטומיים

מחבר: Sanne Grinovero
מהמצגת תלמדו כיצד נוצרה Quarkus, כיצד היא פועלת וכיצד היא מאפשרת לכם להפוך ספריות מורכבות, כמו Hibernate ORM, לתואמות לתמונות מקוריות של GraalVM.

4. למד לפתח אפליקציות ללא שרת

מחבר: מרטין לותר
הסרטון למטה מראה כיצד ליצור יישום Java פשוט באמצעות Quarkus ולפרוס אותו כיישום ללא שרת ב-Knative.

5. קווארקוס: תהנו בקידוד

מחבר: אדסון ינאגה
מדריך וידאו ליצירת פרויקט Quarkus הראשון שלך, המאפשר לך להבין מדוע Quarkus זוכה בלבם של מפתחים.

6. ג'אווה ומכולות - מה יהיה העתיד שלהם ביחד

פורסם על ידי מארק ליטל
מצגת זו מציגה את ההיסטוריה של Java ומסבירה מדוע Quarkus הוא העתיד של Java.

7. Quarkus: Java Subatomic Superfast

מחבר: דימיטריס אנדרדיס
סקירה כללית של היתרונות של Quarkus שזכו להכרה מהמפתחים: פשטות, מהירויות גבוהות במיוחד, הספריות והסטנדרטים הטובים ביותר.

8. קווארקוס ומערכות רקטות תת-אטומיות

מחבר: קלמנט אסקופיר
באמצעות אינטגרציה עם GraalVM, Quarkus מספקת חווית פיתוח מהירה במיוחד וסביבת זמן ריצה תת-אטומית. המחבר מדבר על הצד התגובתי של Quarkus וכיצד להשתמש בו לבניית אפליקציות תגובתיות וסטרימינג.

9. Quarkus ופיתוח מהיר של אפליקציות ב-Eclipse MicroProfile

מחבר: ג'ון קלינגן
על ידי שילוב של Eclipse MicroProfile ו-Quarkus, מפתחים יכולים ליצור יישומי מכולות MicroProfile עם כל התכונות המופעלות תוך עשרות אלפיות שניות. הסרטון מפרט כיצד לקוד אפליקציית MicroProfile מכולת לפריסה בפלטפורמת Kubernetes.

10. Java, גרסת "טורבו".

מחבר: מרקוס ביל
המחבר מראה כיצד להשתמש ב-Quarkus כדי ליצור קונטיינרים סופר-קטנים ומהירים של Java המאפשרים פריצות דרך אמיתיות, במיוחד בסביבות ללא שרת.

מקור: www.habr.com