Dëse Post gouf geschriwwen well eis Mataarbechter zimlech vill Gespréicher mat Clienten iwwer Applikatiounsentwécklung op Kubernetes an d'Spezifizitéite vun esou Entwécklung op OpenShift haten.
Mir fänken normalerweis mat der Dissertatioun un datt Kubernetes just Kubernetes ass, an OpenShift ass schonn eng Kubernetes Plattform, wéi Microsoft AKS oder Amazon EKS. Jiddereng vun dësen Plattformen huet seng eege Virdeeler, riicht op eng bestëmmte Zilgrupp. An duerno geet d'Gespréich op d'Vergläiche vun de Stäerkten a Schwächten vu spezifesche Plattformen.
Am Allgemengen hu mir geduecht dëse Post mat engem Ausgang ze schreiwen wéi "Lauschtert, et ass egal wou Dir de Code leeft, op OpenShift oder op AKS, op EKS, op e puer personaliséierte Kubernetes, jo op all Kubernetes (loosst eis et kuerz KUK nennen) "Et ass wierklech einfach, souwuel do an do."
Duerno hu mir geplangt déi einfachst "Hallo Welt" ze huelen an ze benotzen fir ze weisen wat allgemeng ass a wat d'Ënnerscheeder tëscht der CMC an der Red Hat OpenShift Container Plattform sinn (nodréiglech OCP oder einfach OpenShift).
Wéi och ëmmer, am Laf vum Schreiwen vun dësem Post, hu mir gemierkt datt mir sou gewinnt sinn fir OpenShift ze benotzen datt mir einfach net realiséieren wéi et gewuess ass an zu enger erstaunlecher Plattform ëmgewandelt gouf déi vill méi wéi just eng Kubernetes Verdeelung ginn ass. Mir tendéieren d'Reife an d'Einfachheet vum OpenShift als Selbstverständlech ze huelen, wärend mir iwwer seng Herrlechkeet iwwersiicht.
Am Allgemengen ass d'Zäit komm fir eng aktiv Berouegung ze maachen, an elo wäerte mir Schrëtt fir Schrëtt d'Inbetreiung vun eisem "Hallo Welt" op KUK an op OpenShift vergläichen, a mir maachen et esou objektiv wéi méiglech (gutt, ausser heiansdo e perséinleche weisen Haltung zum Thema). Wann Dir un eng reng subjektiv Meenung zu dësem Thema interesséiert sidd, da kënnt Dir se liesen . An an dësem Post wäerte mir eis un d'Fakten halen an nëmmen d'Fakten.
Cluster
Also, eis "Hallo Welt" brauch Cluster. Mir soen direkt "Nee" zu all ëffentleche Wolleken, fir net fir Serveren, Registry, Netzwierker, Datenübertragung, etc. Deementspriechend wielen mir en einfachen One-Node Cluster op (fir KUK) an (fir en OpenShift Cluster). Béid vun dësen Optiounen si wierklech einfach ze installéieren, awer erfuerderen zimlech vill Ressourcen op Ärem Laptop.
Assemblée op KUK-e
Also loosse mer goen.
Schrëtt 1 - bauen eis Container Bild
Loosst eis ufänken eis "Hallo Welt" op Minikube z'installéieren. Dëst wäert verlaangen:
- 1. Docker installéiert.
- 2. Installéiert Git.
- 3. Installéiert Maven (eigentlech benotzt dëse Projet d'mvnw Binär, also kënnt Dir ouni et maachen).
- 4. Eigentlech ass d'Quell selwer, d.h. Repository Klon
Den éischte Schrëtt ass e Quarkus Projet ze kreéieren. Hutt keng Angscht wann Dir nach ni Quarkus.io benotzt hutt - et ass einfach. Dir wielt just d'Komponenten déi Dir am Projet benotze wëllt (RestEasy, Hibernate, Amazon SQS, Camel, etc.), an dann Quarkus selwer, ouni Är Participatioun, konfiguréiert de Maven Archetyp a setzt alles op github. Dat ass, wuertwiertlech ee Klick vun der Maus - an Dir sidd fäerdeg. Dofir hu mir Quarkus gär.
Deen einfachste Wee fir eis "Hallo Welt" an e Containerbild ze bauen ass d'Quarkus-maven Extensiounen fir Docker ze benotzen, déi all déi néideg Aarbecht maachen. Mat dem Advent vu Quarkus ass dëst wierklech einfach an einfach ginn: Füügt d'Container-Bild-Docker Extensioun an Dir kënnt Biller mat Maven Kommandoen erstellen.
./mvnw quarkus:add-extension -Dextensions=”container-image-docker”
A schliisslech bauen mir eist Bild mat Maven. Als Resultat gëtt eise Quellcode an e fäerdege Containerbild dat scho kann am Container Runtime Ëmfeld lafen.
./mvnw -X clean package -Dquarkus.container-image.build=true
Dat ass tatsächlech alles, elo kënnt Dir de Container mam Docker Run Kommando ausféieren, nodeems Dir eise Service op den Hafen 8080 kartéiert huet fir datt et zougänglech ass.
docker run -i — rm -p 8080:8080 gcolman/quarkus-hello-world
Nodeems d'Containerinstanz ugefaang ass, bleift alles mat dem Curl Kommando ze kontrolléieren datt eise Service leeft:
Also alles funktionnéiert an et war wierklech einfach an einfach.
Schrëtt 2 - Gitt eise Container an de Container Image Repository of
Fir de Moment gëtt d'Bild dat mir erstallt hunn lokal gelagert, an eiser lokaler Containerlagerung. Wa mir dëst Bild an eisem COOK Ëmfeld benotze wëllen, da muss et an engem anere Repository gesat ginn. Kubernetes huet dës Funktiounen net, also wäerte mir dockerhub benotzen. Well éischtens ass et gratis, an zweetens mécht (bal) jiddereen et.
Dëst ass och ganz einfach, an nëmmen en Dockerhub Kont ass hei gebraucht.
Also, mir installéieren dockerhub a schécken eist Bild dohinner.
Schrëtt 3 - Start Kubernetes
Et gi vill Weeër fir d'kubernetes Konfiguratioun ze sammelen fir eis "Hallo Welt" ze lafen, awer mir wäerten déi einfachst vun hinnen benotzen, dat ass de Wee wéi mir sinn ...
Als éischt starten mir de Minikube-Cluster:
minikube start
Schrëtt 4 - Eis Container Image ofsetzen
Elo musse mir eise Code a Containerbild an d'kubernetes Konfiguratioun konvertéieren. An anere Wierder, mir brauche e Pod an eng Deployment Definitioun déi op eise Containerbild op dockerhub weist. Ee vun den einfachste Weeër fir dëst ze maachen ass de Create Deployment Kommando auszeféieren deen op eist Bild weist:
kubectl create deployment hello-quarkus — image =gcolman/quarkus-hello-world:1.0.0-SNAPSHOT
Mat dësem Kommando hu mir eise COO gesot fir eng Deploymentkonfiguratioun ze kreéieren, déi d'Pod Spezifizéierung fir eis Containerbild sollt enthalen. Dëse Kommando wäert dës Konfiguratioun och op eise Minikube-Cluster uwenden, an eng Deployment erstellen, déi eis Containerbild eroflueden an de Pod am Cluster starten.
Schrëtt 5 - oppen Zougang zu eisem Service
Elo datt mir en ofgebauten Containerbild hunn, ass et Zäit ze denken wéi een externen Zougang zu dësem Restful Service konfiguréiert, deen tatsächlech an eisem Code programméiert ass.
Et gi vill Weeër hei. Zum Beispill kënnt Dir d'Expose Kommando benotze fir automatesch déi entspriechend Kubernetes Komponenten ze kreéieren, wéi Servicer an Endpunkter. Eigentlech ass dat wat mir maachen andeems mir de Exposé Kommando fir eisen Deployment Objet ausféieren:
kubectl expose deployment hello-quarkus — type=NodePort — port=8080
Loosst eis e Moment op d'Optioun "-Typ" vum Exposé Kommando wunnen.
Wa mir déi néideg Komponenten ausstelle an erstellen fir eise Service ze bedreiwen, musse mir ënner anerem fäeg sinn vu baussen un den Hello-Quarkus Service ze verbannen, deen an eisem software-definéierten Netzwierk sëtzt. A Parameter Typ erlaabt eis Saachen wéi Lastbalancer ze kreéieren an ze verbannen fir de Traffic op dëst Netzwierk ze routen.
Zum Beispill schreiwen type=LoadBalancer, initialiséieren mir automatesch den ëffentleche Cloud Load Balancer fir mat eisem Kubernetes Cluster ze verbannen. Dëst ass natierlech super, awer Dir musst verstoen datt sou eng Konfiguratioun enk mat enger spezifescher ëffentlecher Wollek gebonnen ass an et wäert méi schwéier sinn et tëscht Kubernetes Instanzen a verschiddenen Ëmfeld ze transferéieren.
An eisem Beispill type=NodePort, dat heescht, den Uruff un eise Service geet duerch d'IP Adress vum Node an d'Portnummer. Dës Optioun erlaabt Iech keng ëffentlech Wolleken ze benotzen, awer erfuerdert eng Rei zousätzlech Schrëtt. Als éischt braucht Dir Ären eegene Lastbalancer, also wäerte mir den NGINX Load Balancer an eisem Cluster ofsetzen.
Schrëtt 6 - Setzt e Lastbalancer op
minikube huet eng Rei vu Plattformfunktiounen déi et méi einfach maachen extern zougänglech Komponenten ze kreéieren, sou wéi Ingress Controller. Minikube kënnt mat dem Nginx Ingress Controller gebündelt, an alles wat mir maache mussen ass et aktivéieren a konfiguréieren.
minikube addons enable ingress
Elo, mat just engem Kommando, wäerte mir en Nginx Ingress Controller erstellen deen an eisem Minikube Cluster funktionnéiert:
ingress-nginx-controller-69ccf5d9d8-j5gs9 1/1 Running 1 33m
Schrëtt 7 - Setzt d'Ingress op
Elo musse mir den Nginx Ingress Controller konfiguréieren sou datt et Hallo-Quarkus Ufroen akzeptéiert.
A schliisslech musse mir dës Konfiguratioun applizéieren.
kubectl apply -f ingress.yml
Well mir dat alles op eisem eegene Computer maachen, addéiere mir einfach d'IP Adress vun eisem Node an d'/etc/ Hosts Datei fir http Ufroen op eise Minikube an den NGINX Loadbalancer ze routen.
192.168.99.100 hello-quarkus.info
Dat ass et, elo ass eise Minikube Service extern zougänglech duerch den Nginx Ingress Controller.
Gutt, dat war einfach, richteg? Oder net wierklech?
Lafen op OpenShift (Code Ready Container)
An elo kucke mer wéi et alles op der Red Hat OpenShift Container Plattform (OCP) gemaach gëtt.
Wéi mat Minikube wielen mir en eenzegen Node OpenShift Cluster Design a Form vu Code Ready Containers (CRC). Virdrun gouf et Minishift genannt a baséiert op dem OpenShift Origin Projet, awer elo ass et CRC a gebaut op Red Hat's OpenShift Container Plattform.
Hei, entschëllegt, mir kënnen net anescht wéi soen: "OpenShift ass super!"
Am Ufank hu mir geduecht ze schreiwen datt d'Entwécklung op OpenShift net anescht ass wéi d'Entwécklung op Kubernetes. An am Fong ass dëst wéi et ass. Awer am Prozess vun dësem Post ze schreiwen, hu mir eis erënnert wéi vill extra Beweegunge Dir maache musst wann Dir keng OpenShift hutt, an dofir ass et erëm wonnerbar. Mir hunn et gär wann alles einfach gemaach gëtt, a wéi einfach eist Beispill ass op OpenShift z'installéieren an ze lafen am Verglach zum Minikube ass wat eis gefrot huet dëse Post ze schreiwen.
Loosst eis duerch de Prozess goen a kucken wat mir maache mussen.
Also, am Minikube Beispill, hu mir mat Docker ugefaang ... Waart, mir brauchen net méi Docker op der Maschinn installéiert.
A mir brauche kee lokale Git.
An Maven ass net néideg.
An Dir musst net e Containerbild mat der Hand erstellen.
An Dir musst net no engem Repository vu Containerbiller sichen.
An et ass net néideg en Ingress Controller z'installéieren.
An Dir braucht och net Ingress ze konfiguréieren.
Verstees de? Fir eis Applikatioun op OpenShift z'installéieren an auszeféieren, ass keng vun den uewe genannten néideg. An de Prozess selwer ass wéi follegt.
Schrëtt 1 - Start Ären OpenShift Cluster
Mir benotzen Code Ready Container vu Red Hat, wat am Wesentlechen deeselwechte Minikube ass, awer nëmme mat engem vollen Single-Node Openshift Cluster.
crc start
Schrëtt 2 - Bauen an deploy d'Applikatioun op den OpenShift Cluster
Et ass op dësem Schrëtt datt d'Einfachheet an d'Bequemlechkeet vun OpenShift sech an all senger Herrlechkeet manifestéieren. Wéi mat all Kubernetes Verdeelungen hu mir vill Weeër fir eng Applikatioun an engem Cluster ze lafen. A wéi am Fall vu KUK, wielt mir speziell déi einfachst.
OpenShift gouf ëmmer als Plattform gebaut fir containeriséiert Uwendungen ze kreéieren an ze lafen. Containergebai war ëmmer en integralen Deel vun dëser Plattform, sou datt et eng Tonn vun zousätzlech Kubernetes Ressourcen fir verwandte Aufgaben ass.
Mir benotze OpenShift's Source 2 Image (S2I) Prozess, deen e puer verschidde Weeër huet fir eis Quell (Code oder Binären) ze huelen an et an e containeriséierte Bild ze maachen deen op engem OpenShift Cluster leeft.
Fir dëst brauche mir zwou Saachen:
- Eise Quellcode ass am Git Repository
- Builder Bild op der Basis vun deem de Bau wäert duerchgefouert ginn.
Et gi vill esou Biller souwuel vum Red Hat wéi och um Gemeinschaftsniveau erhale ginn, a mir wäerten d'OpenJDK-Bild benotzen, gutt, well ech eng Java-Applikatioun bauen.
Dir kënnt de S2I bauen souwuel vun der OpenShift Developer grafesch Konsole wéi och vun der Kommandozeil. Mir benotzen den neien-App Kommando, a soen et wou Dir de Builder Bild an eise Quellcode kritt.
oc new-app registry.access.redhat.com/ubi8/openjdk-11:latest~https://github.com/gcolman/quarkus-hello-world.git
Dat ass et, eis Applikatioun ass erstallt. Dobäi huet de S2I Prozess déi folgend Saachen gemaach:
- Erstellt e Service Build-Pod fir all Zorte vu Saachen am Zesummenhang mat der Applikatioun ze bauen.
- Erstellt d'OpenShift Build Configuratioun.
- Ech hunn de Builderbild an d'intern OpenShift Docker Registry erofgelueden.
- Gekloont "Hallo Welt" zu lokalen Repository.
- Huet gesinn datt et e Maven Pom dra war an esou d'App mat Maven kompiléiert huet.
- Erstellt en neit Containerbild mat der kompiléierter Java Applikatioun an setzt dëst Bild an d'intern Containerregistratioun.
- Erstellt e Kubernetes Deployment mat Spezifikatioune fir e Pod, Service, etc.
- Lancéiert Deploy Container Image.
- Geläscht Service Build-Pod.
Et gëtt vill op dëser Lëscht, awer d'Haaptsach ass datt de ganze Bau exklusiv an OpenShift geschitt, den internen Docker Registry ass bannent OpenShift, an de Bauprozess erstellt all Kubernetes Komponenten a leeft se am Cluster.
Wann Dir visuell de Start vun S2I an der Konsole iwwerwaacht, kënnt Dir gesinn wéi de Build Pod während dem Bau gestart gëtt.
Loosst eis elo d'Builder Pod Logbicher kucken: als éischt weist et wéi Maven seng Aarbecht mécht an Ofhängegkeeten erofluet fir eis Java Applikatioun ze bauen.
Nodeems de Maven Build fäerdeg ass, gëtt de Bau vum Containerbild gestart, an da gëtt dëst gebaut Bild an den internen Repository geschéckt.
Alles, de Montageprozess ass ofgeschloss. Loosst eis elo sécherstellen datt d'Pods a Servicer vun eiser Applikatioun am Cluster ugefaang hunn.
oc get service
Dat ass alles. An et gëtt nëmmen eng Equipe. Alles wat mir maache mussen ass dëse Service fir extern Zougang auszesetzen.
Schrëtt 3 - maachen de Service ausgesat fir Zougang vu baussen
Wéi am Fall vu KUK, op der OpenShift Plattform, brauch eis "Hello World" och e Router fir den externen Traffic op e Service am Cluster ze dirigéieren. An OpenShift mécht dat ganz einfach. Als éischt ass den HAProxy Routing Komponent am Cluster als Standard installéiert (et kann op déiselwecht NGINX geännert ginn). Zweetens ginn et speziell an héich konfiguréierbar Ressourcen genannt Routes, déi un Ingress Objekter a gudden alen Kubernetes erënneren (tatsächlech hunn d'OpenShift Routes staark den Design vun Ingress Objekter beaflosst, déi elo an OpenShift benotzt kënne ginn), awer fir eis "Hallo Welt", a bal all anere Fäll ass d'Standardroute genuch fir eis ouni zousätzlech Konfiguratioun.
Fir e routable FQDN fir "Hallo Welt" ze kreéieren (jo, OpenShiift huet säin eegene DNS fir Routing duerch Servicenimm), wäerte mir eise Service einfach aussetzen:
oc expose service quarkus-hello-world
Wann Dir déi nei erstallt Route kuckt, kënnt Dir de FQDN an aner Routinginformatioun do fannen:
oc get route
A schliisslech hu mir Zougang zu eisem Service vum Browser:
Awer elo war et wierklech einfach!
Mir Léift Kubernetes an alles wat dës Technologie erlaabt Iech ze maachen, a mir Léift och Einfachheet a Liichtegkeet. Kubernetes gouf entwéckelt fir verdeelt, skalierbar Container onheemlech einfach ze bedreiwen, awer seng Einfachheet ass net méi genuch fir Uwendungen haut an d'Produktioun ze bréngen. Dëst ass wou OpenShift an d'Spill kënnt, mat der Zäit hält an Entwéckler-centric Kubernetes ubitt. Vill Effort gouf investéiert fir d'OpenShift Plattform speziell fir den Entwéckler ze personaliséieren, dorënner d'Schafung vun Tools wéi S2I, ODI, Developer Portal, OpenShift Operator Framework, IDE Integratioun, Entwéckler Kataloge, Helm Integratioun, Iwwerwaachung, a vill anerer.
Mir hoffen, datt dësen Artikel interessant an nëtzlech fir Iech war. An Dir fannt zousätzlech Ressourcen, Materialien an aner Saachen nëtzlech fir d'Entwécklung op der OpenShift Plattform um Portal .
Source: will.com