මට සමාවෙන්න, OpenShift, අපි ඔබව ප්‍රමාණවත් තරම් අගය නොකළ අතර ඔබව සුළු කොට තැබුවෙමු

මෙම සටහන ලියා ඇත්තේ අපගේ සේවකයින් Kubernetes හි යෙදුම් සංවර්ධනය සහ OpenShift හි එවැනි සංවර්ධනයේ විශේෂතා පිළිබඳව සේවාදායකයින් සමඟ බොහෝ සංවාද ඇති බැවිනි.

අපි සාමාන්‍යයෙන් පටන් ගන්නේ Kubernetes යනු Kubernetes පමණක් යන නිබන්ධනයෙනි, සහ OpenShift දැනටමත් Microsoft AKS හෝ Amazon EKS වැනි Kubernetes වේදිකාවකි. මෙම සෑම වේදිකාවකටම විශේෂිත ඉලක්කගත ප්‍රේක්ෂකයින් ඉලක්ක කරගත් එහිම වාසි ඇත. මෙයින් පසු, සංවාදය විශේෂිත වේදිකාවල ශක්තීන් සහ දුර්වලතා සංසන්දනය කිරීමට හැරේ.

සාමාන්‍යයෙන්, අපි මෙම සටහන ලිවීමට සිතුවේ “සවන් දෙන්න, ඔබ කේතය ධාවනය කරන්නේ කොතැනද, OpenShift හෝ AKS, EKS, සමහර අභිරුචි කුබර්නෙට් මත, ඔව් ඕනෑම කුබර්නෙටස් වැනි ප්‍රතිදානයක් සමඟිනි. (කෙටියෙන් KUK කියමු) "එය එහි සහ එහි යන දෙකම ඇත්තෙන්ම සරලයි."

ඉන්පසුව අපි සරලම "Hello World" ගෙන එහි උදාහරණය භාවිතා කර KUC සහ Red Hat OpenShift බහාලුම් වේදිකාව (මින් ඉදිරියට OCP හෝ සරලව OpenShift) අතර පොදු කුමක්ද සහ වෙනස කුමක්ද යන්න පෙන්වීමට සැලසුම් කළෙමු.

කෙසේ වෙතත්, මෙම සටහන ලිවීමේදී, අපි OpenShift භාවිතා කිරීමට කොතරම් පුරුදු වී ඇත්ද යත්, එය වර්ධනය වී කුබර්නෙටේස් බෙදා හැරීමකට වඩා බොහෝ වැඩි විස්මිත වේදිකාවක් බවට පත් වී ඇත්තේ කෙසේදැයි අපට නොතේරෙන බව අපට වැටහුණි. අපි OpenShift හි පරිණතභාවය සහ සරල බව සුළු කොට තැකිය යුතු අතර, එහි විශිෂ්ටත්වය නොසලකා හරිමු.

පොදුවේ ගත් කල, ක්‍රියාකාරී පසුතැවිලි වීමට කාලය පැමිණ ඇති අතර, දැන් අපි KUK සහ OpenShift හි අපගේ “Hello World” ආරම්භ කිරීම පියවරෙන් පියවර සංසන්දනය කරන්නෙමු, අපි එය හැකි තරම් වෛෂයිකව කරන්නෙමු (හොඳයි, සමහර විට සමහර විට පුද්ගලික එකක් පෙන්වයි විෂය පිළිබඳ ආකල්පය). ඔබ මෙම ගැටලුව සම්බන්ධයෙන් තනිකරම ආත්මීය මතයක් ගැන උනන්දුවක් දක්වන්නේ නම්, ඔබට එය කියවිය හැකිය මෙන්න (EN). තවද මෙම ලිපියෙන් අපි කරුණු වලට සහ කරුණු වලට පමණක් රැඳී සිටිමු.

පොකුරු

එබැවින්, අපගේ "Hello World" සඳහා පොකුරු අවශ්ය වේ. සේවාදායකයන්, රෙජිස්ට්‍රි, ජාල, දත්ත හුවමාරුව යනාදිය සඳහා නොගෙවීම සඳහා අපි වහාම ඕනෑම පොදු වලාකුළකට “නැහැ” යැයි කියමු. ඒ අනුව, අපි සරල තනි-නෝඩ් පොකුරක් තෝරා ගනිමු මිනිකුබ් (KUK සඳහා) සහ කේත සූදානම් බහාලුම් (OpenShift පොකුර සඳහා). මෙම විකල්ප දෙකම ස්ථාපනය කිරීම ඇත්තෙන්ම පහසුය, නමුත් ඔබේ ලැප්ටොප් පරිගණකයේ බොහෝ සම්පත් අවශ්ය වනු ඇත.

KUK-e මත රැස්වීම

ඉතින් අපි යමු.

පියවර 1 - අපගේ බහාලුම් රූපය ගොඩනැගීම

අපි අපේ "Hello World" minikube වෙත යෙදවීමෙන් පටන් ගනිමු. මෙය අවශ්ය වනු ඇත:

1. 1. ස්ථාපිත Docker.
2. 2. Git ස්ථාපනය කර ඇත.
3. 3. Maven ස්ථාපනය කර ඇත (ඇත්ත වශයෙන්ම, මෙම ව්‍යාපෘතිය mvnw ද්විමය භාවිතා කරයි, එබැවින් ඔබට එය නොමැතිව කළ හැකිය).
4. 4. ඇත්ත වශයෙන්ම, මූලාශ්රයම, i.e. ගබඩා ක්ලෝනය github.com/gcolman/quarkus-hello-world.git

පළමු පියවර වන්නේ Quarkus ව්යාපෘතියක් නිර්මාණය කිරීමයි. ඔබ කවදාවත් Quarkus.io භාවිතා කර නොමැති නම් බිය නොවන්න - එය පහසුයි. ඔබ ව්‍යාපෘතියේ භාවිතා කිරීමට අවශ්‍ය සංරචක (RestEasy, Hibernate, Amazon SQS, Camel, ආදිය) තෝරාගන්න, ඉන්පසු Quarkus විසින්ම, ඔබේ සහභාගීත්වයෙන් තොරව, maven archetype සකසා, github මත සියල්ල තබයි. එනම්, වචනාර්ථයෙන් මූසිකයේ එක් ක්ලික් කිරීමක් - සහ ඔබ අවසන්. මේ නිසා අපි ක්වාර්කස්ට ආදරෙයි.

අපගේ "හෙලෝ වර්ල්ඩ්" බහාලුම් රූපයක් බවට ගොඩනැගීමට ඇති පහසුම ක්‍රමය නම්, අවශ්‍ය සියලුම කාර්යයන් ඉටු කරන ඩොකර් සඳහා ක්වාර්කස්-මේවන් දිගු භාවිතා කිරීමයි. Quarkus පැමිණීමත් සමඟ, මෙය ඇත්තෙන්ම පහසු සහ සරල වී ඇත: බහාලුම්-රූප-ඩොකර් දිගුව එක් කරන්න, ඔබට maven විධාන භාවිතයෙන් පින්තූර නිර්මාණය කළ හැකිය.

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

අවසාන වශයෙන්, අපි Maven භාවිතයෙන් අපගේ ප්‍රතිරූපය ගොඩනඟමු. එහි ප්‍රතිඵලයක් වශයෙන්, අපගේ මූලාශ්‍ර කේතය සූදානම් කළ බහාලුම් රූපයක් බවට පරිවර්තනය වේ, එය දැනටමත් බහාලුම් ධාවන කාලය තුළ ධාවනය කළ හැක.

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

ඇත්ත වශයෙන්ම, එපමණයි, දැන් ඔබට අපගේ සේවාව 8080 වරායට සිතියම්ගත කර ප්‍රවේශ විය හැකි පරිදි ඩොකර් ධාවන විධානය සමඟ කන්ටේනරය ධාවනය කළ හැකිය.

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

බහාලුම් අවස්ථාව ආරම්භ වූ පසු, ඉතිරිව ඇත්තේ අපගේ සේවාව ක්‍රියාත්මක වන බව curl විධානය සමඟ පරීක්ෂා කිරීම පමණි:

එබැවින් සෑම දෙයක්ම ක්රියාත්මක වන අතර එය ඇත්තෙන්ම පහසු සහ සරල විය.

පියවර 2 - අපගේ කන්ටේනරය බහාලුම් රූප ගබඩාවට ඉදිරිපත් කරන්න

දැනට, අප විසින් සාදන ලද රූපය දේශීයව, අපගේ දේශීය බහාලුම් ගබඩාවේ ගබඩා කර ඇත. අපට මෙම රූපය අපගේ COOK පරිසරය තුළ භාවිතා කිරීමට අවශ්‍ය නම්, එය වෙනත් ගබඩාවක තැබිය යුතුය. Kubernetes හි එවැනි විශේෂාංග නොමැත, එබැවින් අපි dockerhub භාවිතා කරන්නෙමු. මන්ද, පළමුව, එය නොමිලේ වන අතර, දෙවනුව, (පාහේ) සෑම කෙනෙකුම එය කරයි.

මෙයද ඉතා සරල වන අතර මෙහි අවශ්‍ය වන්නේ dockerhub ගිණුමක් පමණි.

ඉතින්, අපි dockerhub ස්ථාපනය කර අපගේ රූපය එහි යවන්නෙමු.

පියවර 3 - Kubernetes ආරම්භ කරන්න

අපගේ "Hello World" ක්‍රියාත්මක කිරීම සඳහා kubernetes වින්‍යාසය එකතු කිරීමට බොහෝ ක්‍රම තිබේ, නමුත් අපි ඒවායින් සරලම දේ භාවිතා කරන්නෙමු, මන්ද අපි එවැනි පුද්ගලයින් ...

පළමුව, අපි minikube පොකුර ආරම්භ කරමු:

minikube start

පියවර 4 - අපගේ බහාලුම් රූපය යෙදවීම

දැන් අපි අපගේ කේතය සහ බහාලුම් රූපය kubernetes වින්‍යාසයට පරිවර්තනය කළ යුතුයි. වෙනත් වචන වලින් කිවහොත්, අපට dockerhub හි අපගේ බහාලුම් රූපය වෙත යොමු කරන පොඩ් එකක් සහ යෙදවුම් නිර්වචනයක් අවශ්‍ය වේ. මෙය කිරීමට ඇති පහසුම ක්‍රමයක් නම් අපගේ රූපය වෙත යොමු කරමින් create deployment විධානය ක්‍රියාත්මක කිරීමයි.

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

මෙම විධානය සමඟින්, අපගේ බහාලුම් රූපය සඳහා පොඩ් පිරිවිතර අඩංගු විය යුතු, යෙදවුම් වින්‍යාසයක් නිර්මාණය කරන ලෙස අපි අපගේ COOK ට පැවසුවෙමු. මෙම විධානය අපගේ minikube පොකුරට මෙම වින්‍යාසය යොදන අතර, අපගේ බහාලුම් රූපය බාගත කර පොකුර මත පොඩ් එකක් ධාවනය කරන යෙදවීමක් සාදනු ඇත.

පියවර 5 - අපගේ සේවාව සඳහා විවෘත ප්රවේශය

දැන් අපට යොදවා ඇති බහාලුම් රූපයක් ඇති බැවින්, ඇත්ත වශයෙන්ම අපගේ කේතයේ වැඩසටහන්ගත කර ඇති මෙම විවේක සේවාවට බාහිර ප්‍රවේශය වින්‍යාස කරන්නේ කෙසේද යන්න ගැන සිතීමට කාලයයි.

මෙහි බොහෝ ක්රම තිබේ. උදාහරණයක් ලෙස, ඔබට සේවා සහ අන්ත ලක්ෂ්‍ය වැනි සුදුසු Kubernetes සංරචක ස්වයංක්‍රීයව නිර්මාණය කිරීමට නිරාවරණය විධානය භාවිතා කළ හැක. ඇත්ත වශයෙන්ම, අපගේ යෙදවුම් වස්තුව සඳහා නිරාවරණය විධානය ක්‍රියාත්මක කිරීමෙන් අප කරන්නේ මෙයයි:

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

නිරාවරණ විධානයේ "-type" විකල්පය දෙස අපි මොහොතක් බලමු.

අපි අපගේ සේවාව ක්‍රියාත්මක කිරීමට අවශ්‍ය සංරචක නිරාවරණය කර නිර්මාණය කරන විට, වෙනත් දේ අතර, අපගේ මෘදුකාංග-නිර්වචනය කළ ජාලය තුළ පිහිටා ඇති hello-quarkus සේවාවට පිටතින් සම්බන්ධ වීමට අපට හැකි විය යුතුය. සහ පරාමිතිය වර්ගය මෙම ජාලයට ගමනාගමනය කිරීමට load balancers වැනි දේවල් නිර්මාණය කිරීමට සහ සම්බන්ධ කිරීමට අපට ඉඩ සලසයි.

උදාහරණයක් ලෙස, ලිවීම type=LoadBalancer, අපි අපගේ Kubernetes පොකුරට සම්බන්ධ වීමට පොදු Cloud load balancer ස්වයංක්‍රීයව ආරම්භ කරමු. ඇත්ත වශයෙන්ම මෙය විශිෂ්ටයි, නමුත් එවැනි වින්‍යාසයක් නිශ්චිත පොදු වලාකුළකට තදින් බැඳී ඇති බවත් විවිධ පරිසරවල කුබර්නෙට්ස් අවස්ථා අතර එය මාරු කිරීම වඩාත් අපහසු වනු ඇති බවත් ඔබ තේරුම් ගත යුතුය.

අපගේ උදාහරණයේ type=NodePort, එනම්, අපගේ සේවාවට ඇමතුම නෝඩයේ IP ලිපිනය සහ වරාය අංකය මගින් සිදු වේ. මෙම විකල්පය ඔබට කිසිදු පොදු වලාකුළු භාවිතා නොකිරීමට ඉඩ සලසයි, නමුත් අමතර පියවර ගණනාවක් අවශ්ය වේ. පළමුව, ඔබට ඔබේම load balancer අවශ්‍ය වේ, එබැවින් අපි NGINX load balancer අපගේ පොකුරේ යොදවන්නෙමු.

පියවර 6 - load balancer එකක් ස්ථාපනය කරන්න

minikube සතුව වේදිකා ශ්‍රිත ගණනාවක් ඇති අතර එමඟින් ප්‍රවේශ පාලක වැනි බාහිරව ප්‍රවේශ විය හැකි සංරචක නිර්මාණය කිරීම පහසු කරයි. Minikube පැමිණෙන්නේ Nginx ඇතුල්වීමේ පාලකය සමඟින් වන අතර, අප කළ යුත්තේ එය සක්‍රීය කර එය වින්‍යාස කිරීම පමණි.

minikube addons enable ingress

දැන් අපි එක් විධානයක් සමඟ Nginx ඇතුල්වීමේ පාලකයක් සාදන්නෙමු, එය අපගේ minikube පොකුර තුළ ක්‍රියා කරයි:

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

පියවර 7 - ඇතුල්වීම සකසන්න

දැන් අපි Hello-quarkus ඉල්ලීම් පිළිගන්නා පරිදි Nginx ඇතුල්වීමේ පාලකය වින්‍යාසගත කළ යුතුය.

අවසාන වශයෙන්, අපි මෙම වින්‍යාසය යෙදිය යුතුය.

kubectl apply -f ingress.yml

අපි මේ සියල්ල කරන්නේ අපේම පරිගණකයෙන් නිසා, අපි සරලවම අපගේ මිනිකුබ් වෙත http ඉල්ලීම් NGINX load balancer වෙත යොමු කිරීමට අපගේ node හි IP ලිපිනය /etc/ hosts ගොනුවට එක් කරන්නෙමු.

192.168.99.100 hello-quarkus.info

එපමණයි, දැන් අපගේ minikube සේවාව Nginx ඇතුල්වීමේ පාලකය හරහා පිටතින් ලබා ගත හැකිය.

හොඳයි, එය පහසු විය, හරිද? නැත්නම් එතරම් නොවේද?

OpenShift මත ධාවනය (කේත සූදානම් බහාලුම්)

දැන් අපි බලමු මේ සියල්ල Red Hat OpenShift Container Platform (OCP) මත සිදු කරන්නේ කෙසේදැයි.

minikube මෙන්, අපි කේත සූදානම් බහාලුම් (CRC) ආකාරයෙන් තනි-නෝඩ් OpenShift පොකුරු සැලසුමක් තෝරා ගනිමු. මීට පෙර, එය minishift ලෙස හැඳින්වූ අතර එය OpenShift Origin ව්‍යාපෘතිය මත පදනම් වූ නමුත් දැන් එය CRC වන අතර එය Red Hat හි OpenShift බහාලුම් වේදිකාව මත ගොඩනගා ඇත.

මෙන්න, සමාවෙන්න, අපට උදව් කිරීමට නොහැක: "OpenShift අපූරුයි!"

මුලින්ම අපි ලියන්න හිතුවේ OpenShift හි සංවර්ධන කටයුතු Kubernetes හි සංවර්ධනයට වඩා වෙනස් නොවන බවයි. සහ සාරයෙන් එය එසේ ය. නමුත් මෙම සටහන ලිවීමේ ක්‍රියාවලියේදී, ඔබට OpenShift නොමැති විට ඔබට කොපමණ අමතර චලනයන් කළ යුතුද යන්න අපට මතක ඇති අතර, එය නැවතත් අපූරු ය. සෑම දෙයක්ම පහසුවෙන් සිදු කරන විට අපි එයට ප්‍රිය කරන අතර, minikube හා සසඳන විට OpenShift මත යෙදවීම සහ ධාවනය කිරීම අපගේ උදාහරණය කොතරම් පහසුද යන්න මෙම සටහන ලිවීමට අපව පොළඹවන ලදී.

අපි ක්‍රියාවලිය හරහා ගොස් අප කළ යුතු දේ බලමු.

ඉතින්, minikube උදාහරණයේදී, අපි Docker එකෙන් පටන් ගත්තා... ඉන්න, අපිට තවදුරටත් යන්ත්‍රයේ Docker ස්ථාපනය අවශ්‍ය නැහැ.

අනික අපිට local git ඕනෙත් නෑ.
ඒ වගේම මේවන් අවශ්‍ය නැහැ.
තවද ඔබ අතින් බහාලුම් රූපයක් නිර්මාණය කිරීමට අවශ්ය නොවේ.
තවද ඔබට බහාලුම් රූප ගබඩාවක් සෙවීමට අවශ්‍ය නැත.
තවද ඔබට ඇතුල්වීමේ පාලකයක් ස්ථාපනය කිරීමට අවශ්‍ය නොවේ.
තවද ඔබට ඇතුල්වීම වින්‍යාස කිරීමට අවශ්‍ය නැත.

ඔයාට තේරෙණව ද? OpenShift මත අපගේ යෙදුම යෙදවීමට සහ ධාවනය කිරීමට, ඉහත කිසිවක් අවශ්‍ය නොවේ. සහ ක්රියාවලියම පහත පරිදි වේ.

පියවර 1 - ඔබේ OpenShift පොකුර දියත් කරන්න

අපි Red Hat වෙතින් Code Ready බහාලුම් භාවිතා කරන්නෙමු, එය අත්‍යවශ්‍යයෙන්ම එකම Minikube වේ, නමුත් සම්පූර්ණ තනි-නෝඩ් Openshift පොකුරක් සමඟ පමණි.

crc start

පියවර 2 - OpenShift පොකුරට යෙදුම ගොඩනඟා යෙදවීම

OpenShift හි සරල බව සහ පහසුව එහි සියලු මහිමයෙන් ප්‍රකාශ වන්නේ මෙම පියවරේදීය. සියලුම Kubernetes බෙදාහැරීම් මෙන්ම, පොකුරක් මත යෙදුමක් ධාවනය කිරීමට අපට බොහෝ ක්‍රම තිබේ. තවද, KUK හි මෙන්, අපි විශේෂයෙන් සරලම එක තෝරා ගනිමු.

OpenShift සෑම විටම කන්ටේනරීකරණය කරන ලද යෙදුම් තැනීම සහ ධාවනය කිරීම සඳහා වේදිකාවක් ලෙස ගොඩනගා ඇත. බහාලුම් තැනීම සැමවිටම මෙම වේදිකාවේ අනිවාර්ය අංගයක් වී ඇත, එබැවින් අනුරූප කාර්යයන් සඳහා අමතර Kubernetes සම්පත් සමූහයක් ඇත.

අපි OpenShift's Source 2 Image (S2I) ක්‍රියාවලිය භාවිතා කරන්නෙමු, අපගේ මූලාශ්‍රය (කේතය හෝ ද්විමය) ගෙන එය OpenShift පොකුරක් මත ධාවනය වන බහාලුම් කළ රූපයක් බවට පත් කිරීමට විවිධ ක්‍රම කිහිපයක් ඇත.

මේ සඳහා අපට කරුණු දෙකක් අවශ්ය වේ:

• git ගබඩාවේ ඇති අපගේ මූල කේතය
• ගොඩනැගීම සිදු කරනු ලබන පදනම මත ඉදි කරන්නාගේ රූපය.

Red Hat සහ ප්‍රජාව විසින් නඩත්තු කරන එවැනි පින්තූර බොහොමයක් ඇත, මම ජාවා යෙදුමක් ගොඩනඟන බැවින් අපි OpenJDK රූපය භාවිතා කරන්නෙමු.

ඔබට S2I ගොඩනැගීම OpenShift Developer චිත්‍රක කොන්සෝලයෙන් සහ විධාන රේඛාවෙන් ක්‍රියාත්මක කළ හැක. අපි නව-යෙදුම් විධානය භාවිතා කරන්නෙමු, එය ගොඩනැගීමේ රූපය සහ අපගේ මූලාශ්‍ර කේතය ලබා ගන්නේ කොහෙන්ද යන්න පවසමු.

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

එපමණයි, අපගේ යෙදුම නිර්මාණය කර ඇත. එසේ කිරීමේදී, S2I ක්‍රියාවලිය පහත සඳහන් දේ සිදු කළේය:

• යෙදුම ගොඩනැගීමට අදාළ සියලු වර්ගවල දේවල් සඳහා සේවා ගොඩනැගීම-පොඩ් එකක් සාදන ලදී.
• OpenShift Build config එකක් සාදා ඇත.
• මම බිල්ඩර් රූපය අභ්‍යන්තර OpenShift ඩොකර් රෙජිස්ට්‍රියට බාගත කළෙමි.
• "Hello World" දේශීය ගබඩාවට ක්ලෝන කරන ලදී.
• එහි maven pom එකක් ඇති බව දුටු අතර maven සමඟ යෙදුම සම්පාදනය කළේය.
• සම්පාදනය කරන ලද ජාවා යෙදුම අඩංගු නව බහාලුම් රූපයක් සාදා මෙම රූපය අභ්‍යන්තර බහාලුම් රෙජිස්ට්‍රියට දමන්න.
• Pod, Service, ආදිය සඳහා පිරිවිතර සහිත Kubernetes යෙදවීම නිර්මාණය කරන ලදී.
• මම බහාලුම් රූපය යෙදවීමට පටන් ගතිමි.
• ඉවත් කරන ලද සේවා ගොඩනැගීම-පොඩ්.

මෙම ලැයිස්තුවේ බොහෝ දේ ඇත, නමුත් ප්‍රධාන දෙය නම් සම්පූර්ණ ගොඩනැගීම සිදු වන්නේ OpenShift තුළ පමණි, අභ්‍යන්තර ඩොකර් රෙජිස්ට්‍රිය OpenShift තුළ ඇත, සහ ගොඩනැගීමේ ක්‍රියාවලිය සියලුම Kubernetes සංරචක නිර්මාණය කර ඒවා පොකුරු මත ධාවනය කරයි.

ඔබ කොන්සෝලය තුළ S2I දියත් කිරීම දෘශ්‍යමය වශයෙන් නිරීක්ෂණය කරන්නේ නම්, ගොඩනැගීමේදී බිල්ඩ් පොඩ් දියත් කරන ආකාරය ඔබට දැක ගත හැකිය.

දැන් අපි බිල්ඩර් පොඩ් ලොග් දෙස බලමු: පළමුව, එය අපගේ ජාවා යෙදුම ගොඩනඟා ගැනීමට maven එහි කාර්යය කරන ආකාරය සහ පරායත්තතා බාගත කරන ආකාරය පෙන්වයි.

Maven ගොඩනැගීම අවසන් වූ පසු, බහාලුම් රූපය ගොඩනැගීම ආරම්භ කරනු ලැබේ, පසුව මෙම ගොඩනඟන ලද රූපය අභ්යන්තර ගබඩාව වෙත යවනු ලැබේ.

එපමණයි, ගොඩනැගීමේ ක්රියාවලිය සම්පූර්ණයි. දැන් අපි අපගේ යෙදුමේ කරල් සහ සේවා පොකුරේ ක්‍රියාත්මක වන බවට සහතික කර ගනිමු.

oc get service

එච්චරයි. අනික එක කණ්ඩායමයි ඉන්නේ. අප කළ යුත්තේ මෙම සේවාව බාහිර ප්‍රවේශය සඳහා නිරාවරණය කිරීමයි.

පියවර 3 - පිටත සිට ප්‍රවේශය සඳහා සේවාව හෙළි කරන්න

KUK හි මෙන්, OpenShift වේදිකාවේ, අපගේ "Hello World" හට පොකුර තුළ ඇති සේවාවකට බාහිර ගමනාගමනය යොමු කිරීමට රවුටරයක් ​​අවශ්‍ය වේ. OpenShift හි මෙය ඉතා පහසු කරයි. පළමුව, HAProxy රවුටින් සංරචකය පෙරනිමියෙන් පොකුරේ ස්ථාපනය කර ඇත (එය එකම NGINX වෙත වෙනස් කළ හැක). දෙවනුව, Routes නමින් විශේෂ සහ ඉහළ වින්‍යාසගත කළ හැකි සම්පත් ඇත, ඒවා හොඳ පැරණි Kubernetes හි Ingress වස්තු සිහිපත් කරයි (ඇත්ත වශයෙන්ම, OpenShift's Routes Ingress objects නිර්මාණයට දැඩි ලෙස බලපෑවේ, එය දැන් OpenShift හි භාවිතා කළ හැක) , නමුත් අපගේ "Hello ලෝකය", සහ අනෙකුත් සෑම අවස්ථාවකදීම, අතිරේක වින්‍යාසයකින් තොරව සම්මත මාර්ගය අපට ප්‍රමාණවත් වේ.

"Hello World" සඳහා routable FQDN එකක් සෑදීමට (ඔව්, OpenShiift හට සේවා නම් අනුව මාර්ගගත කිරීම සඳහා තමන්ගේම DNS ඇත), අපි අපගේ සේවාව සරලව හෙළිදරව් කරමු:

oc expose service quarkus-hello-world

ඔබ අලුතින් සාදන ලද මාර්ගය දෙස බැලුවහොත්, ඔබට එහි FQDN සහ අනෙකුත් මාර්ගගත තොරතුරු සොයාගත හැකිය:

oc get route

අවසාන වශයෙන්, අපි අපගේ සේවාව බ්‍රවුසරයෙන් ප්‍රවේශ කරමු:

නමුත් දැන් එය ඇත්තෙන්ම පහසු විය!

අපි Kubernetes ට සහ මෙම තාක්‍ෂණය ඔබට කිරීමට ඉඩ දෙන සෑම දෙයකටම ආදරය කරන අතර අපි සරලත්වයට සහ සැහැල්ලුවටද ප්‍රිය කරමු. Kubernetes නිර්මාණය කර ඇත්තේ බෙදා හරින ලද, පරිමාණය කළ හැකි බහාලුම් ඇදහිය නොහැකි ලෙස ක්‍රියා කිරීමට පහසු කිරීමට, නමුත් එහි සරලත්වය අද යෙදුම් නිෂ්පාදනයට ගෙන ඒමට ප්‍රමාණවත් නොවේ. OpenShift ක්‍රියාත්මක වන ස්ථානය මෙයයි, කාලයට අනුකූලව සහ සංවර්ධක කේන්ද්‍රීය Kubernetes පිරිනමයි. S2I, ODI, Developer Portal, OpenShift Operator Framework, IDE integration, Developer Catalogs, Helm integration, Monitoring, සහ තවත් බොහෝ මෙවලම් නිර්මාණය කිරීම ඇතුළුව, විශේෂයෙන් සංවර්ධකයා සඳහා OpenShift වේදිකාව සකස් කිරීම සඳහා විශාල උත්සාහයක් ආයෝජනය කර ඇත.

මෙම ලිපිය ඔබට රසවත් හා ප්‍රයෝජනවත් වනු ඇතැයි අපි බලාපොරොත්තු වෙමු. ඔබට අතිරේක සම්පත්, ද්‍රව්‍ය සහ සංවර්ධනය සඳහා ප්‍රයෝජනවත් වෙනත් දේවල් ද්වාරයෙහි OpenShift වේදිකාවෙන් සොයාගත හැකිය Red Hat සංවර්ධකයින්.

මූලාශ්රය: www.habr.com