குவார்கஸ் எவ்வாறு கட்டாய மற்றும் எதிர்வினை நிரலாக்கத்தை ஒருங்கிணைக்கிறது

இந்த ஆண்டு கொள்கலன் கருப்பொருள்களை தீவிரமாக உருவாக்க திட்டமிட்டுள்ளோம், கிளவுட்-நேட்டிவ் ஜாவா и Kubernetes. இந்த தலைப்புகளின் தர்க்கரீதியான தொடர்ச்சி ஏற்கனவே குவார்கஸ் கட்டமைப்பைப் பற்றிய கதையாக இருக்கும் கருதப்படுகிறது ஹப்ரே மீது. இன்றைய கட்டுரை "சப்டோமிக் சூப்பர்ஃபாஸ்ட் ஜாவா" வடிவமைப்பைப் பற்றியது மற்றும் குவார்கஸ் நிறுவனத்திற்குக் கொண்டு வரும் வாக்குறுதியைப் பற்றியது.

ஜாவா மற்றும் ஜேவிஎம் இன்னும் பிரபலமாக உள்ளன, ஆனால் சர்வர்லெஸ் தொழில்நுட்பங்கள் மற்றும் கிளவுட்-நேட்டிவ் மைக்ரோ சர்வீஸ்களுடன் பணிபுரியும் போது, ​​ஜாவா மற்றும் பிற ஜேவிஎம் மொழிகள் குறைவாகவே பயன்படுத்தப்படுகின்றன, ஏனெனில் அவை அதிக நினைவக இடத்தை எடுத்துக்கொள்கின்றன மற்றும் ஏற்றுவதற்கு மிகவும் மெதுவாக உள்ளன. குறுகிய கால கொள்கலன்களுடன் பயன்படுத்த மோசமாக பொருத்தமானது. அதிர்ஷ்டவசமாக, இந்த நிலைமை இப்போது குவார்கஸால் மாறத் தொடங்குகிறது.

சூப்பர்ஃபாஸ்ட் துணை அணு ஜாவா ஒரு புதிய நிலையை எட்டியுள்ளது!

42 வெளியீடுகள், 8 மாத சமூகப் பணிகள் மற்றும் 177 அற்புதமான டெவலப்பர்கள் - இதன் விளைவாக நவம்பர் 2019 இல் வெளியிடப்பட்டது குவார்கஸ் 1.0, திட்டத்தின் வளர்ச்சியில் ஒரு முக்கிய மைல்கல்லைக் குறிக்கும் ஒரு வெளியீடு மற்றும் பல அருமையான அம்சங்கள் மற்றும் திறன்களை வழங்குகிறது (நீங்கள் அவற்றைப் பற்றி மேலும் படிக்கலாம் அறிவிப்பு).

குவார்கஸ் எவ்வாறு கட்டாய மற்றும் எதிர்வினை நிரலாக்க மாதிரிகளை ஒற்றை எதிர்வினை மையமாக இணைக்கிறது என்பதை இன்று நாங்கள் உங்களுக்குக் காண்பிப்போம். நாம் ஒரு சுருக்கமான வரலாற்றுடன் தொடங்குவோம், பின்னர் குவார்கஸின் எதிர்வினை மைய இரட்டைவாதம் என்ன, எப்படி என்பதைப் பற்றி விரிவாகப் பார்ப்போம். ஜாவா- டெவலப்பர்கள் இந்த நன்மைகளைப் பயன்படுத்திக் கொள்ளலாம்.

நுண் சேவைகள், நிகழ்வு சார்ந்த கட்டமைப்புகள் и serverlessசெயல்பாடுகள் - இவை அனைத்தும், அவர்கள் சொல்வது போல், இன்று அதிகரித்து வருகின்றன. சமீபத்தில், கிளவுட்-சென்ட்ரிக் ஆர்கிடெக்சர்களை உருவாக்குவது மிகவும் எளிதாகவும் அணுகக்கூடியதாகவும் மாறிவிட்டது, ஆனால் சிக்கல்கள் உள்ளன - குறிப்பாக ஜாவா டெவலப்பர்களுக்கு. எடுத்துக்காட்டாக, சேவையகமற்ற செயல்பாடுகள் மற்றும் மைக்ரோ சர்வீஸ்களின் விஷயத்தில், தொடக்க நேரத்தைக் குறைக்கவும், நினைவக நுகர்வு குறைக்கவும், அவற்றின் வளர்ச்சியை இன்னும் வசதியாகவும் சுவாரஸ்யமாகவும் மாற்றுவது அவசரத் தேவை. ஜாவா சமீபத்திய ஆண்டுகளில் பல மேம்பாடுகளைச் செய்துள்ளது, அதாவது கொள்கலன்களுக்கான மேம்படுத்தப்பட்ட பணிச்சூழலியல் செயல்பாடு மற்றும் பல. இருப்பினும், ஜாவாவை ஒரு கொள்கலனில் சரியாக வேலை செய்வது இன்னும் சவாலானது. எனவே ஜாவாவின் சில உள்ளார்ந்த சிக்கல்களைப் பார்ப்பதன் மூலம் தொடங்குவோம், அவை கொள்கலன் சார்ந்த ஜாவா பயன்பாடுகளை உருவாக்கும் போது குறிப்பாக கடுமையானவை.

முதலில், வரலாற்றைப் பார்ப்போம்.

நீரோடைகள் மற்றும் கொள்கலன்கள்

பதிப்பு 8u131 இல் தொடங்கி, பணிச்சூழலியல் செயல்பாட்டின் மேம்பாடுகள் காரணமாக ஜாவா அதிகமாகவோ அல்லது குறைவாகவோ கொள்கலன்களை ஆதரிக்கத் தொடங்கியது. குறிப்பாக, JVM ஆனது, அது எத்தனை செயலி கோர்களில் இயங்குகிறது என்பதை இப்போது அறிந்திருக்கிறது மற்றும் அதற்கேற்ப த்ரெட் பூல்களை-பொதுவாக ஃபோர்க்/ஜைன் பூல்களை-கட்டமைக்க முடியும். நிச்சயமாக, இது நன்றாக இருக்கிறது, ஆனால் எங்களிடம் ஒரு பாரம்பரிய வலை பயன்பாடு உள்ளது, அது HTTP சர்வ்லெட்டுகளைப் பயன்படுத்துகிறது மற்றும் டாம்கேட், ஜெட்டி போன்றவற்றில் இயங்குகிறது. இதன் விளைவாக, இந்தப் பயன்பாடு ஒவ்வொரு கோரிக்கைக்கும் தனித்தனி நூலை வழங்கும் மற்றும் I/O செயல்பாடுகளுக்காக காத்திருக்கும் போது இந்த தொடரிழையைத் தடுக்க அனுமதிக்கும், எடுத்துக்காட்டாக, தரவுத்தளம், கோப்புகள் அல்லது பிற சேவைகளை அணுகும் போது. அதாவது, அத்தகைய பயன்பாட்டின் அளவு கிடைக்கக்கூடிய கோர்களின் எண்ணிக்கையைப் பொறுத்தது அல்ல, ஆனால் ஒரே நேரத்தில் கோரிக்கைகளின் எண்ணிக்கையைப் பொறுத்தது. கூடுதலாக, இதன் பொருள் என்னவென்றால், குபெர்னெட்டஸில் உள்ள ஒதுக்கீடுகள் அல்லது கோர்களின் எண்ணிக்கையில் வரம்புகள் இங்கு அதிகம் உதவாது, மேலும் விஷயம் இறுதியில் த்ரோட்டில் முடிவடையும்.

நினைவாற்றல் சோர்வு

நூல்கள் நினைவகம். மற்றும் உள்-கொள்கலன் நினைவக வரம்புகள் எந்த வகையிலும் ஒரு சஞ்சீவி அல்ல. பயன்பாடுகள் மற்றும் நூல்களின் எண்ணிக்கையை அதிகரிக்கத் தொடங்குங்கள், விரைவில் அல்லது பின்னர் நீங்கள் மாறுதல் அதிர்வெண்ணில் ஒரு முக்கியமான அதிகரிப்பை சந்திப்பீர்கள், இதன் விளைவாக, செயல்திறன் சரிவு. மேலும், உங்கள் பயன்பாடு பாரம்பரிய மைக்ரோ சர்வீஸ் கட்டமைப்பைப் பயன்படுத்தினால், அல்லது தரவுத்தளத்துடன் இணைத்தால், அல்லது கேச்சிங் பயன்படுத்தினால், அல்லது நினைவகத்தைப் பயன்படுத்தினால், JVM-ன் உள்ளே பார்க்கவும், நினைவகத்தை அழிக்காமல் எப்படி நிர்வகிக்கிறது என்பதைப் பார்க்கவும் உங்களுக்கு ஒரு கருவி தேவை. JVM தானே (உதாரணமாக, XX:+UseCGroupMemoryLimitForHeap). ஜாவா 9 இல் இருந்து, ஜேவிஎம் cgroupகளை ஏற்கவும் அதற்கேற்ப மாற்றவும் கற்றுக்கொண்டாலும், நினைவகத்தை ஒதுக்குவதும் நிர்வகிப்பதும் மிகவும் சிக்கலான விஷயமாகவே உள்ளது.

ஒதுக்கீடுகள் மற்றும் வரம்புகள்

ஜாவா 11 CPU ஒதுக்கீடுகளுக்கான ஆதரவை அறிமுகப்படுத்தியது (PreferContainerQuotaForCPUCount போன்றவை). குபெர்னெட்டஸ் வரம்புகள் மற்றும் ஒதுக்கீடுகளுக்கான ஆதரவையும் வழங்குகிறது. ஆம், இவை அனைத்தும் அர்த்தமுள்ளதாக இருக்கும், ஆனால் பயன்பாடு மீண்டும் ஒதுக்கப்பட்ட ஒதுக்கீட்டை மீறினால், நாங்கள் மீண்டும் அளவுடன் முடிவடைகிறோம் - பாரம்பரிய ஜாவா பயன்பாடுகளைப் போலவே - கோர்களின் எண்ணிக்கை மற்றும் ஒவ்வொன்றிற்கும் ஒரு தனி நூலை ஒதுக்குவதன் மூலம் தீர்மானிக்கப்படுகிறது. வேண்டுகோள், அப்படியானால் இவை அனைத்திலும் சிறிதும் அர்த்தமில்லை.
கூடுதலாக, நீங்கள் ஒதுக்கீடுகள் மற்றும் வரம்புகள் அல்லது குபெர்னெட்டஸின் அடிப்படையிலான இயங்குதளத்தின் அளவுகோல் செயல்பாடுகளைப் பயன்படுத்தினால், சிக்கல் தானாகவே தீர்க்கப்படாது. அசல் சிக்கலைத் தீர்ப்பதற்கு நாங்கள் அதிக ஆதாரங்களைச் செலவிடுகிறோம் அல்லது அதிகச் செலவு செய்கிறோம். பொது மேகக்கணியில் அதிக சுமை கொண்ட அமைப்பாக இருந்தால், நிச்சயமாக நமக்குத் தேவையானதை விட அதிகமான ஆதாரங்களைப் பயன்படுத்துவோம்.

மேலும் இதையெல்லாம் என்ன செய்வது?

எளிமையாகச் சொல்வதானால், ஒத்திசைவற்ற மற்றும் தடையற்ற 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 ஆனது Vert.x மற்றும் Netty ஐ அடிப்படையாகக் கொண்டது, டெவலப்பருக்கு உதவும் வகையில் வினைத்திறன் கட்டமைப்புகள் மற்றும் நீட்டிப்புகள் மேலே உள்ளன. குவார்கஸ் ஆனது HTTP மைக்ரோ சர்வீஸ்கள் மட்டுமின்றி, நிகழ்வு சார்ந்த கட்டமைப்புகளையும் உருவாக்க வடிவமைக்கப்பட்டுள்ளது. அதன் வினைத்திறன் காரணமாக, இது செய்தியிடல் அமைப்புகளுடன் (Apache Kafka, AMQP, முதலியன) மிகவும் திறம்பட செயல்படுகிறது.

கட்டாயம் மற்றும் எதிர்வினை குறியீடு ஆகிய இரண்டிற்கும் ஒரே எதிர்வினை இயந்திரத்தை எவ்வாறு பயன்படுத்துவது என்பது தந்திரம்.

குவார்கஸ் இதை அற்புதமாக செய்கிறார். கட்டாயம் மற்றும் எதிர்வினைக்கு இடையேயான தேர்வு வெளிப்படையானது - இரண்டிற்கும் ஒரு எதிர்வினை கர்னலைப் பயன்படுத்தவும். இது உண்மையில் உதவுவது வேகமான, தடுக்காத குறியீடாகும், இது நிகழ்வு-லூப் த்ரெட், அக்கா IO த்ரெட் வழியாக செல்லும் அனைத்தையும் கையாளுகிறது. ஆனால் உங்களிடம் கிளாசிக் REST அல்லது கிளையன்ட் பக்க பயன்பாடுகள் இருந்தால், Quarkus ஒரு கட்டாய நிரலாக்க மாதிரி தயாராக உள்ளது. எடுத்துக்காட்டாக, குவார்கஸில் உள்ள HTTP ஆதரவு தடையற்ற மற்றும் எதிர்வினை இயந்திரத்தின் (Eclipse Vert.x மற்றும் Netty) பயன்பாட்டை அடிப்படையாகக் கொண்டது. உங்கள் விண்ணப்பத்தால் பெறப்படும் அனைத்து HTTP கோரிக்கைகளும் முதலில் நிகழ்வு வளையத்தின் (IO Thread) மூலம் அனுப்பப்பட்டு, கோரிக்கைகளை நிர்வகிக்கும் குறியீட்டின் பகுதிக்கு அனுப்பப்படும். சேருமிடத்தைப் பொறுத்து, கோரிக்கை மேலாண்மைக் குறியீட்டை ஒரு தனி நூலுக்குள் அழைக்கலாம் (வேர்க்கர் த்ரெட் என்று அழைக்கப்படுவது, சர்வ்லெட்டுகள் மற்றும் ஜாக்ஸ்-ஆர்எஸ் விஷயத்தில் பயன்படுத்தப்படும்) அல்லது மூல I/O நூலைப் (எதிர்வினை வழி) பயன்படுத்தவும்.

செய்தியிடல் அமைப்பு இணைப்பிகள், Vert.x இயந்திரத்தின் மேல் இயங்கும் பிளாக்கிங் அல்லாத கிளையண்டுகளைப் பயன்படுத்துகின்றன. எனவே, நீங்கள் செய்தி அனுப்பும் மிடில்வேர் அமைப்புகளிலிருந்து செய்திகளை திறம்பட அனுப்பலாம், பெறலாம் மற்றும் செயலாக்கலாம்.

தளத்தில் Quarkus.io குவார்கஸைத் தொடங்க உங்களுக்கு உதவும் சில நல்ல பயிற்சிகள் இங்கே:

• எதிர்வினை வழிகளைப் பயன்படுத்துதல்
• எதிர்வினை SQL கிளையண்ட்கள்
• ரியாக்டிவ் மெசேஜிங்குடன் அப்பாச்சி காஃப்காவைப் பயன்படுத்துதல்
• எதிர்வினை செய்தியிடலுடன் AMQP ஐப் பயன்படுத்துதல்
• Vertx API ஐப் பயன்படுத்துகிறது

ஒரு உலாவியில் வினைத்திறன் நிரலாக்கத்தின் பல்வேறு அம்சங்களை உங்களுக்குக் கற்பிக்க ஆன்லைன் பயிற்சிகளையும் நாங்கள் உருவாக்கியுள்ளோம், IDE தேவையில்லை மற்றும் கணினி தேவையில்லை. இந்த பாடங்களை நீங்கள் காணலாம் இங்கே.

பயனுள்ள வளங்கள்

• குவார்கஸை முயற்சிக்க 4 காரணங்கள்
• குவார்கஸ் திட்ட இணையதளம் - quarkus.io
• கிட்ஹப்பில் குவார்கஸ் திட்டம் - github.com/quarkusio/quarkus
• குவார்கஸ் திட்டம் ட்விட்டர் - twitter.com/QuarkusIO
• குவார்கஸ் திட்ட அரட்டை - quarkusio.zulipchat.com
• குவார்கஸ் திட்ட மன்றங்கள் - group.google.com/forum/#!forum/quarkus-dev

தலைப்பைப் பற்றி தெரிந்துகொள்ள குவார்கஸில் 10 வீடியோ பாடங்கள்

என இணையதளத்தில் கூறியுள்ளனர் Quarkus.io, குவார்க்கஸ் - ஆகும் Kubernetes-சார்ந்த ஜாவா ஸ்டேக், GraalVM மற்றும் OpenJDK HotSpot க்கு ஏற்றவாறு வடிவமைக்கப்பட்டது மற்றும் சிறந்த ஜாவா நூலகங்கள் மற்றும் தரநிலைகளிலிருந்து கூடியது.

தலைப்பைப் புரிந்துகொள்ள உங்களுக்கு உதவ, குவார்கஸின் பல்வேறு அம்சங்களையும் அதன் பயன்பாட்டின் எடுத்துக்காட்டுகளையும் உள்ளடக்கிய 10 வீடியோ டுடோரியல்களைத் தேர்ந்தெடுத்துள்ளோம்:

1. குவார்கஸை அறிமுகப்படுத்துகிறது: குபெர்னெட்ஸிற்கான அடுத்த தலைமுறை ஜாவா கட்டமைப்பு

தாமஸ் குவார்ன்ஸ்ட்ரோம் மற்றும் ஜேசன் கிரீன் மூலம்
குபர்னெட்ஸ் மற்றும் சர்வர்லெஸ் சூழல்களுக்கு ஜாவா தளத்தை உருவாக்குவதும், வினைத்திறன் மற்றும் கட்டாய நிரலாக்க மாதிரிகளை ஒரு இயக்க நேர சூழலாக இணைப்பதும் குவார்கஸ் திட்டத்தின் குறிக்கோள் ஆகும், இதனால் டெவலப்பர்கள் பரந்த அளவிலான விநியோகிக்கப்பட்ட பயன்பாட்டு கட்டமைப்புகளுடன் பணிபுரியும் போது தங்கள் அணுகுமுறையை நெகிழ்வாக மாற்ற முடியும். கீழே உள்ள அறிமுக விரிவுரையில் மேலும் அறியவும்.

2. குவார்கஸ்: அதிவிரைவு துணை அணு ஜாவா

மூலம்: பர் சுட்டர்
DevNation Live இன் இந்த வீடியோ டுடோரியல், குபெர்னெட்ஸ்/ஓப்பன்ஷிஃப்ட் சூழலில் எண்டர்பிரைஸ் ஜாவா பயன்பாடுகள், ஏபிஐகள், மைக்ரோ சர்வீஸ்கள் மற்றும் சர்வர்லெஸ் செயல்பாடுகளை மேம்படுத்த, குவார்கஸை எவ்வாறு பயன்படுத்துவது என்பதை விளக்குகிறது.

3. குவார்கஸ் மற்றும் கிரால்விஎம்: ஹைபர்னேட்டை அதிவேகமாக முடுக்கி, துணை அணு அளவுகளுக்குச் சுருக்குகிறது

ஆசிரியர்: Sanne Grinovero
விளக்கக்காட்சியில் இருந்து குவார்கஸ் எப்படி உருவானது, அது எவ்வாறு செயல்படுகிறது மற்றும் ஹைபர்னேட் ORM போன்ற சிக்கலான நூலகங்களை நேட்டிவ் GraalVM படங்களுடன் இணக்கமாக உருவாக்க இது உங்களை அனுமதிக்கிறது.

4. சர்வர்லெஸ் அப்ளிகேஷன்களை உருவாக்க கற்றுக்கொள்ளுங்கள்

ஆசிரியர்: மார்ட்டின் லூதர்
Quarkus ஐப் பயன்படுத்தி ஒரு எளிய ஜாவா பயன்பாட்டை உருவாக்குவது மற்றும் Knative இல் சர்வர்லெஸ் பயன்பாடாக அதை எவ்வாறு பயன்படுத்துவது என்பதை கீழே உள்ள வீடியோ காட்டுகிறது.

5. குவார்கஸ்: வேடிக்கையான குறியீட்டு முறை

ஆசிரியர்: எட்சன் யானகா
உங்கள் முதல் குவார்கஸ் திட்டத்தை உருவாக்குவதற்கான வீடியோ வழிகாட்டி, குவார்கஸ் ஏன் டெவலப்பர்களின் இதயங்களை வெல்கிறது என்பதைப் புரிந்துகொள்ள உங்களை அனுமதிக்கிறது.

6. ஜாவா மற்றும் கொள்கலன்கள் - அவர்களின் எதிர்காலம் எப்படி இருக்கும்

மார்க் லிட்டில் இடுகையிட்டார்
இந்த விளக்கக்காட்சி ஜாவாவின் வரலாற்றை அறிமுகப்படுத்துகிறது மற்றும் குவார்கஸ் ஏன் ஜாவாவின் எதிர்காலம் என்பதை விளக்குகிறது.

7. குவார்கஸ்: அதிவிரைவு துணை அணு ஜாவா

ஆசிரியர்: டிமிட்ரிஸ் ஆண்ட்ரேடிஸ்
டெவலப்பர்களிடமிருந்து அங்கீகாரம் பெற்ற குவார்கஸின் நன்மைகள் பற்றிய கண்ணோட்டம்: எளிமை, அதி-உயர் வேகம், சிறந்த நூலகங்கள் மற்றும் தரநிலைகள்.

8. குவார்கஸ் மற்றும் துணை அணு ராக்கெட் அமைப்புகள்

ஆசிரியர்: கிளெமென்ட் எஸ்கோஃபியர்
GraalVM உடன் ஒருங்கிணைப்பதன் மூலம், குவார்கஸ் அதிவேக வளர்ச்சி அனுபவத்தையும் துணை அணு இயக்க நேர சூழலையும் வழங்குகிறது. குவார்கஸின் எதிர்வினை பக்கத்தைப் பற்றியும், எதிர்வினை மற்றும் ஸ்ட்ரீமிங் பயன்பாடுகளை உருவாக்க அதை எவ்வாறு பயன்படுத்துவது என்பது பற்றியும் ஆசிரியர் பேசுகிறார்.

9. Eclipse MicroProfile இல் குவார்கஸ் மற்றும் விரைவான பயன்பாட்டு மேம்பாடு

ஆசிரியர்: ஜான் கிளிங்கன்
Eclipse MicroProfile மற்றும் Quarkusஐ இணைப்பதன் மூலம், டெவலப்பர்கள் முழு அம்சம் கொண்ட கண்டெய்னரைஸ்டு MicroProfile அப்ளிகேஷன்களை உருவாக்க முடியும். குபெர்னெட்டஸ் பிளாட்ஃபார்மில் பயன்படுத்துவதற்கு, கண்டெய்னரைஸ் செய்யப்பட்ட மைக்ரோ ப்ரோஃபைல் அப்ளிகேஷனை எவ்வாறு குறியிடுவது என்பது குறித்த வீடியோ விரிவாகச் செல்கிறது.

10. ஜாவா, "டர்போ" பதிப்பு

ஆசிரியர்: மார்கஸ் பீல்
மிகச்சிறிய, அதிவேக ஜாவா கொள்கலன்களை உருவாக்க குவார்கஸை எவ்வாறு பயன்படுத்துவது என்பதை ஆசிரியர் காட்டுகிறார், இது உண்மையான முன்னேற்றங்களை செயல்படுத்துகிறது, குறிப்பாக சர்வர் இல்லாத சூழலில்.

ஆதாரம்: www.habr.com