Chapisho hili liliandikwa kwa sababu wafanyikazi wetu walikuwa na mazungumzo machache na wateja kuhusu kuunda programu kwenye Kubernetes na maelezo mahususi ya ukuzaji kama huo kwenye OpenShift.
Kwa kawaida tunaanza na nadharia kwamba Kubernetes ni Kubernetes tu, na OpenShift tayari ni jukwaa la Kubernetes, kama vile Microsoft AKS au Amazon EKS. Kila moja ya majukwaa haya ina faida zake, inayolenga hadhira fulani inayolengwa. Na baada ya hayo, mazungumzo tayari yanapita katika kulinganisha kwa nguvu na udhaifu wa majukwaa maalum.
Kwa ujumla, tulifikiria kuandika chapisho hili na matokeo kama vile "Sikiliza, haijalishi ni wapi unatumia msimbo, kwenye OpenShift au kwenye AKS, kwenye EKS, kwenye Kubernetes maalum, ndio kwenye Kubernetes yoyote. (wacha tuite KUK kwa kifupi) "Ni rahisi sana, huko na huko."
Kisha tukapanga kuchukua "Hujambo Ulimwengu" rahisi zaidi na kuitumia ili kuonyesha kile kinachojulikana na ni tofauti gani kati ya CMC na Jukwaa la Kontena la Red Hat OpenShift (baadaye, OCP au OpenShift kwa urahisi).
Walakini, wakati wa kuandika chapisho hili, tuligundua kuwa tumezoea kutumia OpenShift hivi kwamba hatutambui jinsi imekua na kugeuka kuwa jukwaa la kushangaza ambalo limekuwa zaidi ya usambazaji wa Kubernetes. Tunaelekea kuchukua ukomavu na usahili wa OpenShift kuwa kirahisi, huku tukipuuza ukuu wake.
Kwa ujumla, wakati umefika wa toba ya kweli, na sasa tutalinganisha hatua kwa hatua uagizaji wa "Hello World" yetu kwenye KUK na kwenye OpenShift, na tutafanya kwa kusudi iwezekanavyo (vizuri, isipokuwa wakati mwingine kuonyesha kibinafsi. mtazamo kwa mada). Ikiwa una nia ya maoni ya kibinafsi juu ya suala hili, basi unaweza kuisoma . Na katika chapisho hili tutashikamana na ukweli na ukweli tu.
Vikundi
Kwa hivyo, "Hujambo Ulimwengu" wetu unahitaji vikundi. Wacha tuseme "hapana" kwa mawingu yoyote ya umma, ili usilipe seva, rejista, mitandao, uhamishaji wa data, nk. Ipasavyo, tunachagua nguzo rahisi ya nodi moja (kwa KUK) na (kwa nguzo ya OpenShift). Chaguzi hizi zote mbili ni rahisi sana kusakinisha, lakini zinahitaji rasilimali nyingi kwenye kompyuta yako ndogo.
Mkutano juu ya KUK-e
Basi twende.
Hatua ya 1 - Kuunda Picha ya Kontena Yetu
Wacha tuanze kwa kupeleka "Hujambo Ulimwengu" wetu kwa minikube. Ili kufanya hivyo utahitaji:
- 1. Docker imewekwa.
- 2. Git imewekwa.
- 3. Imewekwa Maven (kwa kweli, mradi huu unatumia mvnw binary, hivyo unaweza kufanya bila hiyo).
- 4. Kweli, chanzo yenyewe, i.e. clone ya hazina
Hatua ya kwanza ni kuunda mradi wa Quarkus. Usiogope ikiwa hujawahi kutumia Quarkus.io - ni rahisi. Unachagua tu vipengele unavyotaka kutumia katika mradi (RestEasy, Hibernate, Amazon SQS, Camel, nk), na kisha Quarkus yenyewe, bila ushiriki wako wowote, inasanidi archetype ya maven na kuweka kila kitu kwenye github. Hiyo ni, bonyeza moja tu ya panya - na umemaliza. Hii ndiyo sababu tunapenda Quarkus.
Njia rahisi zaidi ya kujenga "Hujambo Ulimwengu" wetu katika picha iliyo na kontena ni kutumia viendelezi vya quarcus-maven kwa Docker, ambayo itafanya kazi yote muhimu. Pamoja na ujio wa Quarkus, hii imekuwa rahisi na rahisi sana: ongeza kiendelezi cha picha ya kontena na unaweza kuunda picha kwa amri za maven.
./mvnw quarkus:add-extension -Dextensions=βcontainer-image-dockerβ
Na mwishowe, tunaunda picha yetu kwa kutumia Maven. Kwa hivyo, msimbo wetu wa chanzo hubadilika kuwa picha ya kontena iliyotengenezwa tayari, ambayo inaweza tayari kuendeshwa katika muda wa matumizi wa kontena.
./mvnw -X clean package -Dquarkus.container-image.build=true
Hiyo, kwa kweli, ndiyo yote, sasa unaweza kuendesha kontena kwa amri ya docker, baada ya kuweka ramani ya huduma yetu kwa bandari 8080 ili iweze kufikiwa.
docker run -i β rm -p 8080:8080 gcolman/quarkus-hello-world
Baada ya mfano wa chombo kuanza, kilichobaki ni kuangalia na amri ya curl ambayo huduma yetu inaendelea:
Kwa hivyo, kila kitu kinafanya kazi, na ilikuwa rahisi sana na rahisi.
Hatua ya 2 - Wasilisha chombo chetu kwenye hifadhi ya picha ya chombo
Kwa sasa, picha tuliyounda imehifadhiwa ndani, katika hifadhi yetu ya ndani ya kontena. Ikiwa tunataka kutumia picha hii katika mazingira yetu ya COOK, basi lazima iwekwe kwenye hifadhi nyingine. Kubernetes haina vipengele hivi, kwa hivyo tutatumia dockerhub. Kwa sababu, kwanza, ni bure, na pili, (karibu) kila mtu hufanya hivyo.
Hii pia ni rahisi sana, na tu akaunti ya dockerhub inahitajika hapa.
Kwa hiyo, tunaweka dockerhub na kutuma picha yetu huko.
Hatua ya 3 - Anza Kubernetes
Kuna njia nyingi za kukusanya usanidi wa kubernetes ili kuendesha "Hello World", lakini tutatumia rahisi zaidi kati yao, hivyo ndivyo tulivyo...
Kwanza, tunaanza nguzo ya minikube:
minikube start
Hatua ya 4 - Kutuma Picha ya Kontena Yetu
Sasa tunahitaji kubadilisha msimbo wetu na picha ya kontena kuwa usanidi wa kubernetes. Kwa maneno mengine, tunahitaji ganda na ufafanuzi wa upelekaji unaoelekeza kwenye picha ya chombo chetu kwenye dockerhub. Mojawapo ya njia rahisi za kufanya hivyo ni kutekeleza amri ya kuunda kupeleka inayoelekeza kwa picha yetu:
kubectl create deployment hello-quarkus β image =gcolman/quarkus-hello-world:1.0.0-SNAPSHOT
Kwa amri hii, tulimwambia COOK wetu kuunda usanidi wa kupeleka, ambao unapaswa kuwa na vipimo vya pod kwa picha ya chombo chetu. Amri hii pia itatumia usanidi huu kwa nguzo yetu ya minikube, na kuunda utumaji ambao utapakua picha ya kontena letu na kuendesha ganda kwenye nguzo.
Hatua ya 5 - fungua ufikiaji wa huduma yetu
Sasa kwa kuwa tuna picha ya chombo kilichowekwa, ni wakati wa kufikiri juu ya jinsi ya kusanidi ufikiaji wa nje kwa huduma hii ya Restful, ambayo, kwa kweli, imepangwa katika kanuni yetu.
Kuna njia nyingi hapa. Kwa mfano, unaweza kutumia amri ya kufichua kuunda kiotomatiki vipengele vinavyofaa vya Kubernetes kama vile huduma na sehemu za mwisho. Kwa kweli, hii ndio tutafanya kwa kutekeleza amri ya kufichua kwa kitu chetu cha kupeleka:
kubectl expose deployment hello-quarkus β type=NodePort β port=8080
Wacha tukae kwenye chaguo la "-type" la amri ya kufichua kwa muda.
Tunapofichua na kuunda vipengee vinavyohitajika ili kuendesha huduma yetu, tunahitaji, miongoni mwa mambo mengine, kuweza kuunganisha kutoka nje hadi huduma ya hello-quarkus ambayo iko ndani ya mtandao wetu ulioainishwa na programu. Na parameter aina huturuhusu kuunda na kuunganisha vitu kama vile visawazisha mizigo ili kuelekeza trafiki kwenye mtandao huo.
Kwa mfano, kuandika type=LoadBalancer, tunaanzisha kiotomatiki kiweka usawazishaji cha upakiaji wa wingu ya umma ili kuunganisha kwenye nguzo yetu ya Kubernetes. Hii, kwa kweli, ni nzuri, lakini unahitaji kuelewa kuwa usanidi kama huo utafungwa kwa wingu maalum la umma na itakuwa ngumu zaidi kuihamisha kati ya matukio ya Kubernetes katika mazingira tofauti.
Katika mfano wetu type=NodePort, yaani, wito kwa huduma yetu huenda kwa anwani ya IP ya node na nambari ya bandari. Chaguo hili hukuruhusu usitumie mawingu yoyote ya umma, lakini inahitaji hatua kadhaa za ziada. Kwanza, unahitaji kusawazisha mzigo wako mwenyewe, kwa hivyo tutapeleka usawazishaji wa mzigo wa NGINX kwenye nguzo yetu.
Hatua ya 6 - Weka mizani ya mzigo
minikube ina idadi ya vipengele vya jukwaa ambavyo hurahisisha kuunda vipengee unavyohitaji kwa ufikiaji wa nje, kama vile vidhibiti vya ingress. Minikube inakuja ikiwa na kidhibiti cha kuingiza cha Nginx, na tunachotakiwa kufanya ni kuiwezesha na kuisanidi.
minikube addons enable ingress
Sasa, kwa amri moja tu, tutaunda kidhibiti cha ingress cha Nginx ambacho kitafanya kazi ndani ya nguzo yetu ya minikube:
ingress-nginx-controller-69ccf5d9d8-j5gs9 1/1 Running 1 33m
Hatua ya 7 - Weka ingress
Sasa tunahitaji kusanidi kidhibiti cha kuingiza cha Nginx ili kukubali maombi ya hello-quarkus.
Na hatimaye, tunahitaji kutumia usanidi huu.
kubectl apply -f ingress.yml
Kwa kuwa tunafanya haya yote kwenye mashine yetu wenyewe, tunaongeza tu anwani ya IP ya nodi kwenye /etc/hosts faili ili kuelekeza maombi ya http kwa minikube yetu kwa kisawazisha cha upakiaji cha NGINX.
192.168.99.100 hello-quarkus.info
Ni hivyo, sasa huduma yetu ya minikube inapatikana kutoka nje kupitia kidhibiti cha kuingiza cha Nginx.
Kweli, hiyo ilikuwa rahisi, sawa? Au sio sana?
Endesha kwenye OpenShift (Vyombo Tayari vya Msimbo)
Na sasa hebu tuone jinsi yote yanafanywa kwenye Jukwaa la Kontena la Red Hat OpenShift (OCP).
Kama ilivyo kwa minikube, tunachagua mpango ulio na nguzo ya OpenShift ya nodi moja katika mfumo wa Misimbo Tayari Kontena (CRC). Ilikuwa ikiitwa minishift na ilitokana na mradi wa OpenShift Origin, lakini sasa ni CRC na imejengwa kwenye Jukwaa la Kontena la OpenShift la Red Hat.
Hapa, samahani, hatuwezi kujizuia kusema: "OpenShift ni nzuri!"
Hapo awali, tulifikiria kuandika kwamba maendeleo kwenye OpenShift sio tofauti na maendeleo kwenye Kubernetes. Na kwa kweli, ndivyo ilivyo. Lakini katika mchakato wa kuandika chapisho hili, tulikumbuka ni harakati ngapi za ziada unapaswa kufanya wakati huna OpenShift, na ndiyo sababu, tena, ni ya ajabu. Tunaipenda wakati kila kitu kinafanywa kwa urahisi, na jinsi mfano wetu ulivyo rahisi kusambaza na kuendesha kwenye OpenShift ikilinganishwa na minikube ndiyo iliyotusukuma kuandika chapisho hili.
Wacha tupitie mchakato huo na tuone kile tunachohitaji kufanya.
Kwa hiyo, katika mfano wa minikube, tulianza na Docker ... Subiri, hatuhitaji tena Docker imewekwa kwenye mashine.
Na hatuhitaji git ya ndani.
Na Maven haihitajiki.
Na sio lazima kuunda picha ya chombo kwa mkono.
Na sio lazima utafute hazina yoyote ya picha za kontena.
Na huna haja ya kusakinisha kidhibiti cha ingress.
Na hauitaji kusanidi ingress pia.
Unaelewa? Ili kupeleka na kuendesha programu yetu kwenye OpenShift, hakuna yoyote ya hapo juu inahitajika. Na mchakato yenyewe ni kama ifuatavyo.
Hatua ya 1 - Kuanzisha Nguzo yako ya OpenShift
Tunatumia Vikontena vya Code Ready kutoka Red Hat, ambayo kimsingi ni Minikube sawa, lakini tu na nguzo kamili ya Openshift ya nodi moja.
crc start
Hatua ya 2 - Jenga na Upeleke Programu kwenye Nguzo ya OpenShift
Ni katika hatua hii kwamba unyenyekevu na urahisi wa OpenShift hujidhihirisha katika utukufu wake wote. Kama ilivyo kwa usambazaji wote wa Kubernetes, tuna njia nyingi za kuendesha programu kwenye nguzo. Na, kama ilivyo kwa KUK, tunachagua moja rahisi zaidi.
OpenShift daima imekuwa ikijengwa kama jukwaa la kujenga na kuendesha programu zilizo na kontena. Kujenga vyombo daima imekuwa sehemu muhimu ya jukwaa hili, kwa hivyo kuna rundo la rasilimali za ziada za Kubernetes kwa kazi zinazolingana.
Tutakuwa tukitumia mchakato wa OpenShift's Source 2 Image (S2I), ambao una njia kadhaa tofauti za kuchukua chanzo chetu (msimbo au jozi) na kuibadilisha kuwa picha iliyo na kontena inayoendesha kwenye nguzo ya OpenShift.
Kwa hili tunahitaji vitu viwili:
- Nambari yetu ya chanzo kwenye hazina ya git
- Picha ya mjenzi, kulingana na ambayo mkusanyiko utafanyika.
Kuna picha nyingi kama hizo, zinazotunzwa na Red Hat na jamii, na tutatumia picha ya OpenJDK, vizuri, kwa kuwa ninaunda programu ya Java.
Unaweza kuendesha muundo wa S2I kutoka kwa kiweko cha picha cha OpenShift Developer na kutoka kwa safu ya amri. Tutatumia amri ya programu-mpya, kuiambia mahali pa kupata picha ya mjenzi na msimbo wetu wa chanzo.
oc new-app registry.access.redhat.com/ubi8/openjdk-11:latest~https://github.com/gcolman/quarkus-hello-world.git
Hiyo ndiyo yote, maombi yetu yameundwa. Kwa kufanya hivyo, mchakato wa S2I ulifanya mambo yafuatayo:
- Imeunda kiboreshaji cha huduma kwa kila aina ya vitu vinavyohusiana na kuunda programu.
- Imeunda usanidi wa OpenShift Build.
- Nilipakua picha ya mjenzi kwenye sajili ya ndani ya OpenShift docker.
- Imeunganishwa "Hujambo Ulimwengu" kwenye hazina ya ndani.
- Niliona kuna maven pom mle ndani na kwa hivyo akakusanya programu na maven.
- Imeunda picha mpya ya kontena iliyo na programu ya Java iliyokusanywa na kuweka picha hii kwenye sajili ya chombo cha ndani.
- Imeunda Usambazaji wa Kubernetes na vipimo vya ganda, huduma, n.k.
- Imezinduliwa picha ya chombo cha kusambaza.
- Imeondoa ganda la ujenzi wa huduma.
Kuna mengi kwenye orodha hii, lakini jambo kuu ni kwamba ujenzi mzima unafanyika ndani ya OpenShift pekee, sajili ya ndani ya Docker iko ndani ya OpenShift, na mchakato wa ujenzi huunda vifaa vyote vya Kubernetes na kuziendesha kwenye nguzo.
Ikiwa utafuatilia kuibua uzinduzi wa S2I kwenye koni, unaweza kuona jinsi ganda la ujenzi linazinduliwa wakati wa ujenzi.
Na sasa hebu tuangalie magogo ya ganda la wajenzi: kwanza, hapo unaweza kuona jinsi maven inavyofanya kazi yake na utegemezi wa upakuaji ili kujenga programu yetu ya java.
Baada ya ujenzi wa maven kukamilika, ujenzi wa picha ya chombo huanza, na kisha picha hii iliyojengwa inatumwa kwa hazina ya ndani.
Kila kitu, mchakato wa kusanyiko umekamilika. Sasa hebu tuhakikishe kwamba maganda na huduma za programu yetu zimeanza kwenye nguzo.
oc get service
Ni hayo tu. Na kuna timu moja tu. Tunachopaswa kufanya ni kufichua huduma hii kwa ufikiaji wa nje.
Hatua ya 3 - fanya huduma iwe wazi kwa ufikiaji kutoka nje
Kama ilivyo kwa KUK, kwenye jukwaa la OpenShift, "Hujambo Ulimwengu" wetu pia unahitaji kipanga njia ili kuelekeza trafiki ya nje kwa huduma ndani ya nguzo. Katika OpenShift hii inafanya kuwa rahisi sana. Kwanza, sehemu ya uelekezaji ya HAProxy imewekwa kwenye nguzo kwa chaguo-msingi (inaweza kubadilishwa kuwa NGINX sawa). Pili, kuna rasilimali maalum na zinazoweza kusanidiwa sana zinazoitwa Njia, ambazo ni ukumbusho wa vitu vya Ingress katika Kubernetes nzuri za zamani (kwa kweli, Njia za OpenShift ziliathiri sana muundo wa vitu vya Ingress, ambavyo sasa vinaweza kutumika katika OpenShift) , lakini kwa "Hello" yetu. Ulimwengu", na karibu katika visa vingine vyote, Njia ya kawaida inatutosha bila usanidi wa ziada.
Ili kuunda FQDN inayoweza kubadilishwa ya "Hujambo Ulimwenguni" (ndiyo, OpenShiift ina DNS yake ya kuelekeza kwa majina ya huduma), tunafichua huduma yetu kwa urahisi:
oc expose service quarkus-hello-world
Ukiangalia Njia mpya iliyoundwa, basi unaweza kupata FQDN na habari zingine za uelekezaji hapo:
oc get route
Na hatimaye, tunapata huduma yetu kutoka kwa kivinjari:
Lakini sasa ilikuwa rahisi sana!
Tunapenda Kubernetes na kila kitu ambacho teknolojia hii inakuruhusu kufanya, na pia tunapenda urahisi na wepesi. Kubernetes iliundwa ili kufanya kontena zinazosambazwa, zinazoweza kupanuka kuwa rahisi sana kufanya kazi, lakini unyenyekevu wake hautoshi tena kuleta programu katika uzalishaji leo. Hapa ndipo OpenShift inapoanza kutumika, ikiendana na nyakati na kutoa Kubernetes inayozingatia msanidi programu. Juhudi nyingi zimewekezwa kurekebisha jukwaa la OpenShift mahususi kwa msanidi programu, ikijumuisha uundaji wa zana kama vile S2I, ODI, Tovuti ya Wasanidi Programu, Mfumo wa Opereta wa OpenShift, ujumuishaji wa IDE, Katalogi za Wasanidi Programu, ujumuishaji wa Helm, ufuatiliaji, na zingine nyingi.
Tunatarajia kwamba makala hii ilikuwa ya kuvutia na yenye manufaa kwako. Na unaweza kupata rasilimali za ziada, nyenzo na vitu vingine muhimu kwa kukuza kwenye jukwaa la OpenShift kwenye lango .
Chanzo: mapenzi.com