மன்னிக்கவும், OpenShift, நாங்கள் உங்களை போதுமான அளவு பாராட்டவில்லை மற்றும் உங்களை சாதாரணமாக எடுத்துக் கொண்டோம்

Kubernetes இல் பயன்பாடுகளை உருவாக்குவது மற்றும் OpenShift இல் அத்தகைய மேம்பாட்டின் பிரத்தியேகங்கள் குறித்து எங்கள் ஊழியர்கள் வாடிக்கையாளர்களுடன் சில உரையாடல்களை மேற்கொண்டதால் இந்த இடுகை எழுதப்பட்டது.

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

பொதுவாக, இந்த இடுகையை "கேளுங்கள், நீங்கள் குறியீட்டை எங்கு இயக்குகிறீர்கள் என்பது முக்கியமில்லை, OpenShift அல்லது AKS, EKS, சில தனிப்பயன் குபெர்னெட்கள், ஆம் எந்த குபர்னெட்டிலும் (சுருக்கமாக KUK என்று அழைப்போம்) "இது மிகவும் எளிது, அங்கேயும் அங்கேயும்."

பின்னர் எளிமையான "ஹலோ வேர்ல்ட்" ஐ எடுத்து, CMC மற்றும் Red Hat OpenShift கொள்கலன் பிளாட்ஃபார்ம் (இனி OCP அல்லது வெறுமனே OpenShift) ஆகியவற்றுக்கு இடையேயான பொதுவானது மற்றும் வேறுபாடுகள் என்ன என்பதைக் காட்ட அதைப் பயன்படுத்த திட்டமிட்டோம்.

இருப்பினும், இந்த இடுகையை எழுதும் போது, ​​ஓபன்ஷிஃப்டைப் பயன்படுத்துவதற்கு நாங்கள் மிகவும் பழகிவிட்டோம் என்பதை உணர்ந்தோம், அது எப்படி வளர்ந்து ஒரு அற்புதமான தளமாக மாறியது என்பதை நாங்கள் உணரவில்லை, இது குபெர்னெட்ஸ் விநியோகத்தை விட அதிகமாக மாறியுள்ளது. OpenShift இன் முதிர்ச்சியையும் எளிமையையும் ஒரு பொருட்டாக எடுத்துக்கொள்கிறோம், அதே நேரத்தில் அதன் மகத்துவத்தை கவனிக்கவில்லை.

பொதுவாக, செயலில் மனந்திரும்புவதற்கான நேரம் வந்துவிட்டது, இப்போது KUK மற்றும் OpenShift இல் எங்கள் "ஹலோ வேர்ல்ட்" பணியை படிப்படியாக ஒப்பிட்டுப் பார்ப்போம், மேலும் அதை முடிந்தவரை புறநிலையாக செய்வோம் (சரி, சில நேரங்களில் தனிப்பட்டதைக் காட்டுவதைத் தவிர). பொருள் மீதான அணுகுமுறை). இந்த பிரச்சினையில் முற்றிலும் அகநிலை கருத்தில் நீங்கள் ஆர்வமாக இருந்தால், நீங்கள் அதைப் படிக்கலாம் இங்கே (EN). மேலும் இந்த இடுகையில் நாம் உண்மைகளையும் உண்மைகளையும் மட்டுமே கடைப்பிடிப்போம்.

கொத்துகள்

எனவே, எங்கள் "ஹலோ வேர்ல்ட்" க்கு கிளஸ்டர்கள் தேவை. சர்வர்கள், பதிவேடுகள், நெட்வொர்க்குகள், தரவு பரிமாற்றம் போன்றவற்றுக்கு பணம் செலுத்தாமல் இருக்க, எந்த பொது மேகங்களுக்கும் "இல்லை" என்று சொல்லலாம். அதன்படி, நாங்கள் ஒரு எளிய ஒரு முனை கிளஸ்டரை தேர்வு செய்கிறோம் மினிகுப் (KUK க்கான) மற்றும் குறியீடு தயார் கொள்கலன்கள் (OpenShift கிளஸ்டருக்கு). இந்த இரண்டு விருப்பங்களும் நிறுவ மிகவும் எளிதானது, ஆனால் உங்கள் மடிக்கணினியில் நிறைய ஆதாரங்கள் தேவைப்படும்.

KUK-e இல் சட்டசபை

எனவே போகலாம்.

படி 1 - எங்கள் கொள்கலன் படத்தை உருவாக்குதல்

நமது "ஹலோ வேர்ல்ட்"ஐ minikubeக்கு பயன்படுத்துவதன் மூலம் ஆரம்பிக்கலாம். இதற்கு தேவைப்படும்:

1. 1. நிறுவப்பட்ட டோக்கர்.
2. 2. நிறுவப்பட்ட Git.
3. 3. நிறுவப்பட்ட மேவன் (உண்மையில், இந்த திட்டம் mvnw பைனரியைப் பயன்படுத்துகிறது, எனவே நீங்கள் அதை இல்லாமல் செய்யலாம்).
4. 4. உண்மையில், மூலமே, அதாவது. களஞ்சிய குளோன் github.com/gcolman/quarkus-hello-world.git

முதல் படி குவார்கஸ் திட்டத்தை உருவாக்குவது. நீங்கள் Quarkus.io ஐப் பயன்படுத்தவில்லை என்றால் பயப்பட வேண்டாம் - இது எளிதானது. திட்டத்தில் நீங்கள் பயன்படுத்த விரும்பும் கூறுகளை (RestEasy, Hibernate, Amazon SQS, Camel, முதலியன) தேர்ந்தெடுக்கவும், பின்னர் Quarkus தானே, உங்கள் பங்கேற்பு எதுவுமின்றி, மேவன் ஆர்க்கிடைப்பை அமைத்து, எல்லாவற்றையும் கிதுப்பில் வைக்கிறது. அதாவது, சுட்டியின் ஒரே கிளிக்கில் - நீங்கள் முடித்துவிட்டீர்கள். இதனால்தான் நாங்கள் குவார்கஸை விரும்புகிறோம்.

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

./mvnw quarkus:add-extension -Dextensions=”container-image-docker”

இறுதியாக, மேவனைப் பயன்படுத்தி எங்கள் படத்தை உருவாக்குகிறோம். இதன் விளைவாக, எங்கள் மூலக் குறியீடு ஒரு ஆயத்த கொள்கலன் படமாக மாறும், இது ஏற்கனவே கொள்கலன் இயக்க நேரத்தில் இயக்கப்படலாம்.

./mvnw -X clean package -Dquarkus.container-image.build=true

உண்மையில், அவ்வளவுதான், இப்போது நீங்கள் டோக்கர் ரன் கட்டளையுடன் கொள்கலனை இயக்கலாம், எங்கள் சேவையை போர்ட் 8080 க்கு வரைபடமாக்குவதன் மூலம் அதை அணுக முடியும்.

docker run -i — rm -p 8080:8080 gcolman/quarkus-hello-world

கொள்கலன் நிகழ்வைத் தொடங்கிய பிறகு, எங்கள் சேவை இயங்குகிறதா என்பதை கர்ல் கட்டளை மூலம் சரிபார்க்க வேண்டும்:

எனவே, எல்லாம் வேலை செய்கிறது, அது மிகவும் எளிதானது மற்றும் எளிமையானது.

படி 2 - எங்கள் கொள்கலனை கொள்கலன் பட களஞ்சியத்தில் சமர்ப்பிக்கவும்

இப்போதைக்கு, நாங்கள் உருவாக்கிய படம் எங்கள் உள்ளூர் கொள்கலன் சேமிப்பகத்தில் உள்ளூரில் சேமிக்கப்படுகிறது. இந்த படத்தை நமது KUK சூழலில் பயன்படுத்த விரும்பினால், அதை வேறு ஏதாவது களஞ்சியத்தில் வைக்க வேண்டும். Kubernetes இல் இந்த அம்சங்கள் இல்லை, எனவே நாங்கள் dockerhub ஐப் பயன்படுத்துவோம். ஏனெனில், முதலில், இது இலவசம், இரண்டாவதாக, (கிட்டத்தட்ட) எல்லோரும் அதைச் செய்கிறார்கள்.

இதுவும் மிகவும் எளிமையானது, இங்கு dockerhub கணக்கு மட்டுமே தேவை.

எனவே, நாங்கள் dockerhub ஐ நிறுவி எங்கள் படத்தை அங்கு அனுப்புகிறோம்.

படி 3 - குபெர்னெட்டஸைத் தொடங்கவும்

எங்கள் "ஹலோ வேர்ல்ட்" ஐ இயக்க குபெர்னெட்ஸ் உள்ளமைவை ஒன்றிணைக்க பல வழிகள் உள்ளன, ஆனால் அவற்றில் எளிமையானதைப் பயன்படுத்துவோம், ஏனென்றால் நாங்கள் அத்தகையவர்கள் ...

முதலில், மினிகுப் கிளஸ்டரைத் தொடங்குகிறோம்:

minikube start

படி 4 - எங்கள் கொள்கலன் படத்தை வரிசைப்படுத்துதல்

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

kubectl create deployment hello-quarkus — image =gcolman/quarkus-hello-world:1.0.0-SNAPSHOT

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

படி 5 - எங்கள் சேவைக்கான அணுகலைத் திறக்கவும்

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

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

kubectl expose deployment hello-quarkus — type=NodePort — port=8080

எக்ஸ்போஸ் கட்டளையின் "-வகை" விருப்பத்தில் ஒரு கணம் தங்குவோம்.

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

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

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

படி 6 - சுமை சமநிலையை அமைக்கவும்

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

minikube addons enable ingress

இப்போது, ​​ஒரே ஒரு கட்டளையுடன், எங்கள் மினிகுப் கிளஸ்டருக்குள் செயல்படும் ஒரு Nginx நுழைவுக் கட்டுப்படுத்தியை உருவாக்குவோம்:

ingress-nginx-controller-69ccf5d9d8-j5gs9 1/1 Running 1 33m

படி 7 - உட்செலுத்தலை அமைக்கவும்

இப்போது நாம் ஹலோ-குவார்கஸ் கோரிக்கைகளை ஏற்க Nginx நுழைவு கட்டுப்படுத்தியை உள்ளமைக்க வேண்டும்.

இறுதியாக, நாம் இந்த கட்டமைப்பைப் பயன்படுத்த வேண்டும்.

kubectl apply -f ingress.yml

இவை அனைத்தையும் நாங்கள் எங்கள் சொந்த கணினியில் செய்து வருவதால், NGINX லோட் பேலன்சருக்கு http கோரிக்கைகளை எங்கள் minikubeக்கு அனுப்புவதற்கு, /etc/hosts கோப்பில் எங்கள் முனையின் ஐபி முகவரியைச் சேர்ப்போம்.

192.168.99.100 hello-quarkus.info

அவ்வளவுதான், இப்போது எங்கள் minikube சேவை Nginx இன்க்ரஸ் கன்ட்ரோலர் மூலம் வெளியில் இருந்து கிடைக்கிறது.

சரி, அது எளிதாக இருந்தது, இல்லையா? அல்லது இவ்வளவு இல்லையா?

OpenShift இல் இயக்கவும் (குறியீடு தயார் கொள்கலன்கள்)

இப்போது Red Hat OpenShift கன்டெய்னர் பிளாட்ஃபார்மில் (OCP) எப்படி எல்லாம் செய்யப்படுகிறது என்பதைப் பார்ப்போம்.

minikube இன் விஷயத்தைப் போலவே, கோட் ரெடி கன்டெய்னர்கள் (CRC) வடிவில் ஒற்றை முனை OpenShift கிளஸ்டருடன் ஒரு திட்டத்தை நாங்கள் தேர்வு செய்கிறோம். இது மினிஷிஃப்ட் என்று அழைக்கப்பட்டது மற்றும் ஓபன்ஷிஃப்ட் ஆரிஜின் திட்டத்தை அடிப்படையாகக் கொண்டது, ஆனால் இப்போது இது CRC மற்றும் Red Hat இன் OpenShift கொள்கலன் பிளாட்ஃபார்மில் கட்டப்பட்டது.

இங்கே, மன்னிக்கவும், நாங்கள் உதவி செய்ய முடியாது: "OpenShift நன்றாக உள்ளது!"

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

செயல்முறை மூலம் நாம் என்ன செய்ய வேண்டும் என்று பார்க்கலாம்.

எனவே மினிகுப் எடுத்துக்காட்டில், நாங்கள் டோக்கரில் தொடங்கினோம்… காத்திருங்கள், இனி டோக்கரை கணினியில் நிறுவ வேண்டிய அவசியமில்லை.

எங்களுக்கு உள்ளூர் ஜிட் தேவையில்லை.
மேலும் மேவன் தேவையில்லை.
மேலும் நீங்கள் ஒரு கொள்கலன் படத்தை கையால் உருவாக்க வேண்டியதில்லை.
மேலும் கொள்கலன் படங்களின் எந்த களஞ்சியத்தையும் நீங்கள் தேட வேண்டியதில்லை.
மற்றும் நீங்கள் ஒரு நுழைவு கட்டுப்படுத்தி நிறுவ தேவையில்லை.
நீங்கள் நுழைவை உள்ளமைக்க தேவையில்லை.

உனக்கு புரிகிறதா? OpenShift இல் எங்கள் பயன்பாட்டை வரிசைப்படுத்தவும் இயக்கவும், மேலே உள்ள எதுவும் தேவையில்லை. மற்றும் செயல்முறை தன்னை பின்வருமாறு.

படி 1 - உங்கள் OpenShift கிளஸ்டரைத் தொடங்குதல்

Red Hat இலிருந்து Code Ready கண்டெய்னர்களைப் பயன்படுத்துகிறோம், இது அடிப்படையில் அதே Minikube ஆகும், ஆனால் முழு ஒற்றை முனை Openshift கிளஸ்டருடன் மட்டுமே.

crc start

படி 2 - OpenShift கிளஸ்டருக்கு விண்ணப்பத்தை உருவாக்கி வரிசைப்படுத்தவும்

இந்த கட்டத்தில் தான் OpenShift இன் எளிமையும் வசதியும் அதன் அனைத்து மகிமையிலும் வெளிப்படுகிறது. அனைத்து குபெர்னெட்ஸ் விநியோகங்களைப் போலவே, ஒரு கிளஸ்டரில் பயன்பாட்டை இயக்க பல வழிகள் உள்ளன. மேலும், KUK ஐப் போலவே, நாங்கள் குறிப்பாக எளிமையான ஒன்றைத் தேர்வு செய்கிறோம்.

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

நாங்கள் OpenShift இன் Source 2 Image (S2I) செயல்முறையைப் பயன்படுத்துவோம், இது எங்கள் மூலத்தை (குறியீடு அல்லது பைனரிகள்) எடுத்து OpenShift கிளஸ்டரில் இயங்கும் ஒரு கண்டெய்னரைஸ்டு படமாக மாற்ற பல்வேறு வழிகளைக் கொண்டுள்ளது.

இதற்கு நமக்கு இரண்டு விஷயங்கள் தேவை:

• ஜிட் களஞ்சியத்தில் உள்ள எங்கள் மூல குறியீடு
• பில்டர்-படம், அதன் அடிப்படையில் சட்டசபை நிகழ்த்தப்படும்.

இதுபோன்ற பல படங்கள் Red Hat மற்றும் சமூகத்தால் பராமரிக்கப்படுகின்றன, மேலும் OpenJDK படத்தைப் பயன்படுத்துவோம், ஏனெனில் நான் ஜாவா பயன்பாட்டை உருவாக்குகிறேன்.

நீங்கள் OpenShift டெவலப்பர் வரைகலை கன்சோலில் இருந்தும் கட்டளை வரியிலிருந்தும் S2I கட்டமைப்பை இயக்கலாம். நாங்கள் புதிய-ஆப் கட்டளையைப் பயன்படுத்துவோம், பில்டர் படத்தையும் எங்கள் மூலக் குறியீட்டையும் எங்கிருந்து பெறுவது என்பதைக் கூறுவோம்.

oc new-app registry.access.redhat.com/ubi8/openjdk-11:latest~https://github.com/gcolman/quarkus-hello-world.git

அவ்வளவுதான், எங்கள் பயன்பாடு உருவாக்கப்பட்டது. அவ்வாறு செய்யும்போது, ​​S2I செயல்முறை பின்வரும் விஷயங்களைச் செய்தது:

• அப்ளிகேஷனை உருவாக்குவது தொடர்பான அனைத்து வகையான விஷயங்களுக்காகவும் ஒரு சர்வீஸ் பில்ட்-பாட் உருவாக்கப்பட்டது.
• OpenShift Build கட்டமைப்பை உருவாக்கியது.
• பில்டர் படத்தை உள் OpenShift டோக்கர் பதிவேட்டில் பதிவிறக்கம் செய்தேன்.
• உள்ளூர் களஞ்சியத்திற்கு "ஹலோ வேர்ல்ட்" குளோன் செய்யப்பட்டது.
• அங்கே ஒரு மேவன் போம் இருப்பதைப் பார்த்தேன், அதனால் மேவனுடன் பயன்பாட்டைத் தொகுத்தேன்.
• தொகுக்கப்பட்ட ஜாவா பயன்பாட்டைக் கொண்ட ஒரு புதிய கொள்கலன் படத்தை உருவாக்கி, இந்த படத்தை உள் கொள்கலன் பதிவேட்டில் வைக்கவும்.
• ஒரு பாட், சேவை போன்றவற்றிற்கான விவரக்குறிப்புகளுடன் குபெர்னெட்ஸ் வரிசைப்படுத்தலை உருவாக்கியது.
• வரிசைப்படுத்தல் கொள்கலன் படம் தொடங்கப்பட்டது.
• சர்வீஸ் பில்ட்-பாட் அகற்றப்பட்டது.

இந்த பட்டியலில் நிறைய உள்ளது, ஆனால் முக்கிய விஷயம் என்னவென்றால், முழு உருவாக்கமும் OpenShift க்குள் பிரத்தியேகமாக நடைபெறுகிறது, உள் டோக்கர் பதிவேட்டில் OpenShift க்குள் உள்ளது, மேலும் உருவாக்க செயல்முறை அனைத்து Kubernetes கூறுகளையும் உருவாக்கி அவற்றை கிளஸ்டரில் இயக்குகிறது.

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

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

மேவன் உருவாக்கம் முடிந்ததும், கொள்கலன் படத்தின் உருவாக்கம் தொடங்கப்பட்டது, பின்னர் இந்த கட்டப்பட்ட படம் உள் களஞ்சியத்திற்கு அனுப்பப்படும்.

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

oc get service

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

படி 3 - வெளியில் இருந்து அணுகுவதற்கு சேவையை வெளிப்படுத்துங்கள்

KUK ஐப் போலவே, OpenShift இயங்குதளத்தில், எங்கள் "ஹலோ வேர்ல்ட்" க்கு வெளிப்புற போக்குவரத்தை கிளஸ்டருக்குள் உள்ள சேவைக்கு அனுப்ப ஒரு திசைவி தேவை. OpenShift இல் இது மிகவும் எளிதாக்குகிறது. முதலாவதாக, HAProxy ரூட்டிங் கூறு கிளஸ்டரில் இயல்பாக நிறுவப்பட்டுள்ளது (இதை அதே NGINXக்கு மாற்றலாம்). இரண்டாவதாக, Routes எனப்படும் சிறப்பு மற்றும் மிகவும் உள்ளமைக்கக்கூடிய ஆதாரங்கள் உள்ளன, அவை நல்ல பழைய குபெர்னெட்டஸில் உள்ள உட்செலுத்துதல் பொருட்களை நினைவூட்டுகின்றன (உண்மையில், OpenShift இன் வழிகள் Ingress ஆப்ஜெக்ட்களின் வடிவமைப்பை பெரிதும் பாதித்தன, அவை இப்போது OpenShift இல் பயன்படுத்தப்படலாம்) , ஆனால் எங்கள் "ஹலோ உலகம்", மற்றும் கிட்டத்தட்ட எல்லா நிகழ்வுகளிலும், கூடுதல் உள்ளமைவு இல்லாமல் நிலையான பாதை எங்களுக்கு போதுமானது.

“ஹலோ வேர்ல்டு” க்கான ரூட்டபிள் FQDN ஐ உருவாக்க (ஆம், சேவைப் பெயர்களின் மூலம் ரூட்டிங் செய்வதற்கு OpenShift க்கு அதன் சொந்த DNS உள்ளது), நாங்கள் எங்கள் சேவையை வெறுமனே வெளிப்படுத்துகிறோம்:

oc expose service quarkus-hello-world

நீங்கள் புதிதாக உருவாக்கப்பட்ட வழியைப் பார்த்தால், FQDN மற்றும் பிற ரூட்டிங் தகவல்களை அங்கே காணலாம்:

oc get route

இறுதியாக, உலாவியில் இருந்து எங்கள் சேவையை அணுகுவோம்:

ஆனால் இப்போது அது மிகவும் எளிதாக இருந்தது!

நாங்கள் குபெர்னெட்டஸ் மற்றும் இந்த தொழில்நுட்பம் உங்களை அனுமதிக்கும் அனைத்தையும் விரும்புகிறோம், மேலும் எளிமை மற்றும் லேசான தன்மையையும் நாங்கள் விரும்புகிறோம். குபெர்னெட்ஸ் விநியோகிக்கப்பட்ட, அளவிடக்கூடிய கொள்கலன்களை நம்பமுடியாத அளவிற்கு எளிதாக இயக்க வடிவமைக்கப்பட்டுள்ளது, ஆனால் அதன் எளிமை இன்று பயன்பாடுகளை உற்பத்திக்கு கொண்டு வர போதுமானதாக இல்லை. இங்குதான் ஓபன்ஷிஃப்ட் செயல்பாட்டுக்கு வருகிறது, இது நேரத்துடன் ஒத்துப்போகிறது மற்றும் குபெர்னெட்ஸை முதன்மையாக டெவலப்பரை மையமாகக் கொண்டுள்ளது. S2I, ODI, டெவலப்பர் போர்டல், OpenShift ஆபரேட்டர் கட்டமைப்பு, IDE ஒருங்கிணைப்பு, டெவலப்பர் பட்டியல்கள், ஹெல்ம் ஒருங்கிணைப்பு, கண்காணிப்பு மற்றும் பல போன்ற கருவிகளை உருவாக்குவது உட்பட, டெவலப்பருக்காக குறிப்பாக OpenShift இயங்குதளத்தை வடிவமைக்க நிறைய முயற்சிகள் முதலீடு செய்யப்பட்டுள்ளன.

இந்த கட்டுரை உங்களுக்கு சுவாரஸ்யமாகவும் பயனுள்ளதாகவும் இருந்தது என்று நம்புகிறோம். மேலும் ஓபன்ஷிப்ட் இயங்குதளத்தில் உருவாக்குவதற்குப் பயனுள்ள கூடுதல் ஆதாரங்கள், பொருட்கள் மற்றும் பிற விஷயங்களை நீங்கள் போர்ட்டலில் காணலாம் Red Hat டெவலப்பர்கள்.

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