Kubernetesలో అప్లికేషన్‌లను డెవలప్ చేయడం మరియు OpenShiftలో అటువంటి డెవలప్‌మెంట్ యొక్క ప్రత్యేకతల గురించి మా సిబ్బంది క్లయింట్‌లతో చాలా తక్కువ సంభాషణలు చేసినందున ఈ పోస్ట్ వ్రాయబడింది.
మేము సాధారణంగా Kubernetes కేవలం Kubernetes అని థీసిస్‌తో ప్రారంభిస్తాము మరియు OpenShift ఇప్పటికే మైక్రోసాఫ్ట్ AKS లేదా Amazon EKS వంటి కుబెర్నెట్స్ ప్లాట్‌ఫారమ్. ఈ ప్లాట్‌ఫారమ్‌లలో ప్రతి దాని స్వంత ప్రయోజనాలను కలిగి ఉంది, నిర్దిష్ట లక్ష్య ప్రేక్షకులపై దృష్టి సారిస్తుంది. మరియు ఆ తర్వాత, సంభాషణ ఇప్పటికే నిర్దిష్ట ప్లాట్‌ఫారమ్‌ల బలాలు మరియు బలహీనతల పోలికలోకి ప్రవహిస్తుంది.
సాధారణంగా, మేము ఈ పోస్ట్‌ను “వినండి, మీరు ఓపెన్‌షిఫ్ట్‌లో లేదా ఎకెఎస్‌లో, ఇకెఎస్‌లో, కొన్ని కస్టమ్ కుబెర్నెట్‌లలో, అవును ఏదైనా కుబెర్నెట్‌లలో కోడ్‌ని ఎక్కడ అమలు చేస్తారనేది పట్టింపు లేదు. (దీన్ని సంక్షిప్తంగా KUK అని పిలుద్దాం) "ఇది చాలా సులభం, అక్కడ మరియు అక్కడ రెండూ."
అప్పుడు మేము సరళమైన "హలో వరల్డ్"ని తీసుకోవాలని మరియు CMC మరియు Red Hat OpenShift కంటైనర్ ప్లాట్‌ఫారమ్ (ఇకపై OCP లేదా కేవలం OpenShift) మధ్య ఏది సాధారణమో మరియు తేడాలు ఏమిటో చూపించడానికి దానిని ఉపయోగించాలని ప్లాన్ చేసాము.
అయితే, ఈ పోస్ట్‌ను వ్రాసేటప్పుడు, మేము OpenShiftని ఉపయోగించడం చాలా అలవాటు చేసుకున్నామని మేము గ్రహించాము, అది ఎలా పెరిగిందో మరియు కేవలం కుబెర్నెట్స్ పంపిణీ కంటే చాలా ఎక్కువగా మారిన అద్భుతమైన ప్లాట్‌ఫారమ్‌గా మారిందని మేము గుర్తించలేము. మేము OpenShift యొక్క పరిపక్వత మరియు సరళత యొక్క గొప్పతనాన్ని పట్టించుకోకుండా, దాని యొక్క పరిపక్వత మరియు సరళతను మంజూరు చేస్తాము.
సాధారణంగా, చురుకైన పశ్చాత్తాపం కోసం సమయం ఆసన్నమైంది మరియు ఇప్పుడు మేము KUK మరియు ఓపెన్‌షిఫ్ట్‌లో మా “హలో వరల్డ్” యొక్క కమీషన్‌ను దశలవారీగా పోల్చి చూస్తాము మరియు మేము దీన్ని వీలైనంత నిష్పక్షపాతంగా చేస్తాము (అలాగే, కొన్నిసార్లు వ్యక్తిగతంగా చూపడం మినహా. విషయం పట్ల వైఖరి). మీరు ఈ సమస్యపై పూర్తిగా ఆత్మాశ్రయ అభిప్రాయంపై ఆసక్తి కలిగి ఉంటే, మీరు దానిని చదవవచ్చు . మరియు ఈ పోస్ట్‌లో మేము వాస్తవాలకు మరియు వాస్తవాలకు మాత్రమే కట్టుబడి ఉంటాము.
క్లస్టర్లు
కాబట్టి, మా "హలో వరల్డ్"కి క్లస్టర్లు అవసరం. సర్వర్‌లు, రిజిస్ట్రీలు, నెట్‌వర్క్‌లు, డేటా బదిలీ మొదలైన వాటికి చెల్లించకుండా ఉండటానికి, ఏదైనా పబ్లిక్ క్లౌడ్‌లకు "నో" అని చెప్పండి. దీని ప్రకారం, మేము సాధారణ సింగిల్-నోడ్ క్లస్టర్‌ని ఎంచుకుంటాము (KUK కోసం) మరియు (ఓపెన్‌షిఫ్ట్ క్లస్టర్ కోసం). ఈ రెండు ఎంపికలు ఇన్‌స్టాల్ చేయడం చాలా సులభం, కానీ మీ ల్యాప్‌టాప్‌లో చాలా వనరులు అవసరం.
KUK-eపై అసెంబ్లీ
కనుక మనము వెళ్దాము.
దశ 1 - మా కంటైనర్ చిత్రాన్ని రూపొందించడం
మన “హలో వరల్డ్”ని మినీక్యూబ్‌కి అమలు చేయడం ద్వారా ప్రారంభిద్దాం. దీనికి ఇది అవసరం:
- 1. ఇన్‌స్టాల్ చేయబడిన డాకర్.
- 2. Git ఇన్‌స్టాల్ చేయబడింది.
- 3. ఇన్‌స్టాల్ చేయబడిన మావెన్ (వాస్తవానికి, ఈ ప్రాజెక్ట్ mvnw బైనరీని ఉపయోగిస్తుంది, కాబట్టి మీరు అది లేకుండా చేయవచ్చు).
- 4. వాస్తవానికి, మూలం కూడా, అనగా. రిపోజిటరీ క్లోన్
మొదటి దశ క్వార్కస్ ప్రాజెక్ట్‌ను రూపొందించడం. మీరు 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ని ఉపయోగిస్తాము. ఎందుకంటే, మొదట, ఇది ఉచితం, మరియు రెండవది, (దాదాపు) ప్రతి ఒక్కరూ దీన్ని చేస్తారు.
ఇది కూడా చాలా సులభం మరియు ఇక్కడ డాకర్‌హబ్ ఖాతా మాత్రమే అవసరం.
కాబట్టి, మేము డాకర్‌హబ్‌ని ఇన్‌స్టాల్ చేసి, మా చిత్రాన్ని అక్కడికి పంపుతాము.
దశ 3 - కుబెర్నెట్స్ ప్రారంభించండి
మా "హలో వరల్డ్"ని అమలు చేయడానికి కుబెర్నెట్స్ కాన్ఫిగరేషన్‌ను సమీకరించడానికి అనేక మార్గాలు ఉన్నాయి, కానీ మేము వాటిలో సరళమైనదాన్ని ఉపయోగిస్తాము, అదే మనం...
ముందుగా, మేము మినీక్యూబ్ క్లస్టర్‌ను ప్రారంభిస్తాము:
minikube start
దశ 4 - మా కంటైనర్ చిత్రాన్ని అమలు చేయడం
ఇప్పుడు మనం మన కోడ్ మరియు కంటైనర్ ఇమేజ్‌ని kubernetes కాన్ఫిగరేషన్‌కి మార్చాలి. మరో మాటలో చెప్పాలంటే, డాకర్‌హబ్‌లోని మా కంటైనర్ ఇమేజ్‌ని సూచించే పాడ్ మరియు డిప్లాయ్‌మెంట్ డెఫినిషన్ అవసరం. దీన్ని చేయడానికి సులభమైన మార్గాలలో ఒకటి, మా చిత్రాన్ని సూచించే క్రియేట్ డిప్లాయ్‌మెంట్ కమాండ్‌ను అమలు చేయడం:
kubectl create deployment hello-quarkus — image =gcolman/quarkus-hello-world:1.0.0-SNAPSHOT
ఈ ఆదేశంతో, మేము మా కంటైనర్ ఇమేజ్ కోసం పాడ్ స్పెసిఫికేషన్‌ను కలిగి ఉండే విస్తరణ కాన్ఫిగరేషన్‌ని సృష్టించమని మా COOKకి చెప్పాము. ఈ కమాండ్ ఈ కాన్ఫిగరేషన్‌ను మా మినీక్యూబ్ క్లస్టర్‌కి కూడా వర్తింపజేస్తుంది మరియు మా కంటైనర్ ఇమేజ్‌ని డౌన్‌లోడ్ చేసి క్లస్టర్‌పై పాడ్‌ను రన్ చేసే డిప్లాయ్‌మెంట్‌ను సృష్టిస్తుంది.
దశ 5 - మా సేవకు ఓపెన్ యాక్సెస్
ఇప్పుడు మేము అమర్చిన కంటైనర్ ఇమేజ్‌ని కలిగి ఉన్నాము, ఈ రెస్ట్‌ఫుల్ సేవకు బాహ్య ప్రాప్యతను ఎలా కాన్ఫిగర్ చేయాలో ఆలోచించాల్సిన సమయం వచ్చింది, వాస్తవానికి ఇది మా కోడ్‌లో ప్రోగ్రామ్ చేయబడింది.
ఇక్కడ అనేక మార్గాలు ఉన్నాయి. ఉదాహరణకు, సర్వీస్‌లు మరియు ఎండ్‌పాయింట్‌ల వంటి తగిన కుబెర్నెట్స్ భాగాలను స్వయంచాలకంగా సృష్టించడానికి మీరు ఎక్స్‌పోజ్ కమాండ్‌ను ఉపయోగించవచ్చు. వాస్తవానికి, మా డిప్లాయ్‌మెంట్ ఆబ్జెక్ట్ కోసం ఎక్స్‌పోజ్ కమాండ్‌ని అమలు చేయడం ద్వారా మనం దీన్ని చేస్తాము:
kubectl expose deployment hello-quarkus — type=NodePort — port=8080
ఎక్స్‌పోజ్ కమాండ్ యొక్క "-టైప్" ఎంపికపై ఒక క్షణం నివసిద్దాం.
మేము మా సేవను అమలు చేయడానికి అవసరమైన భాగాలను బహిర్గతం చేసి, సృష్టించినప్పుడు, ఇతర విషయాలతోపాటు, మా సాఫ్ట్‌వేర్-నిర్వచించిన నెట్‌వర్క్‌లో ఉన్న హలో-క్వార్కస్ సేవకు వెలుపలి నుండి కనెక్ట్ అయ్యేలా మనకు అవసరం. మరియు పరామితి రకం ఆ నెట్‌వర్క్‌కి ట్రాఫిక్‌ను రూట్ చేయడానికి లోడ్ బ్యాలెన్సర్‌ల వంటి వాటిని సృష్టించడానికి మరియు కనెక్ట్ చేయడానికి మమ్మల్ని అనుమతిస్తుంది.
ఉదాహరణకు, రాయడం రకం = లోడ్ బ్యాలన్సర్, మేము మా Kubernetes క్లస్టర్‌కి కనెక్ట్ చేయడానికి పబ్లిక్ క్లౌడ్ లోడ్ బ్యాలెన్సర్‌ని స్వయంచాలకంగా ప్రారంభిస్తాము. ఇది చాలా బాగుంది, కానీ అటువంటి కాన్ఫిగరేషన్ నిర్దిష్ట పబ్లిక్ క్లౌడ్‌తో గట్టిగా ముడిపడి ఉంటుందని మీరు అర్థం చేసుకోవాలి మరియు వివిధ వాతావరణాలలో కుబెర్నెట్స్ ఉదాహరణల మధ్య దానిని బదిలీ చేయడం చాలా కష్టం.
మా ఉదాహరణలో రకం=నోడ్‌పోర్ట్, అంటే, మా సేవకు కాల్ నోడ్ యొక్క IP చిరునామా మరియు పోర్ట్ నంబర్ ద్వారా వెళుతుంది. ఈ ఐచ్ఛికం ఏ పబ్లిక్ క్లౌడ్‌లను ఉపయోగించకుండా మిమ్మల్ని అనుమతిస్తుంది, కానీ అనేక అదనపు దశలు అవసరం. ముందుగా, మీకు మీ స్వంత లోడ్ బ్యాలెన్సర్ అవసరం, కాబట్టి మేము మా క్లస్టర్‌లో 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 అభ్యర్థనలను మా మినీక్యూబ్‌కు మళ్లించడానికి మేము మా నోడ్ యొక్క IP చిరునామాను /etc/hosts ఫైల్‌కి జోడిస్తాము.
192.168.99.100 hello-quarkus.info
అంతే, ఇప్పుడు మా మినీక్యూబ్ సేవ Nginx ఇన్‌గ్రెస్ కంట్రోలర్ ద్వారా బయటి నుండి అందుబాటులో ఉంది.
బాగా, అది సులభం, సరియైనదా? లేదా అంత కాదా?
OpenShiftలో అమలు చేయండి (కోడ్ సిద్ధంగా ఉన్న కంటైనర్లు)
మరియు ఇప్పుడు Red Hat OpenShift కంటైనర్ ప్లాట్‌ఫారమ్ (OCP)లో ఇది ఎలా జరిగిందో చూద్దాం.
minikube విషయంలో వలె, మేము కోడ్ రెడీ కంటైనర్‌ల (CRC) రూపంలో సింగిల్-నోడ్ OpenShift క్లస్టర్‌తో స్కీమ్‌ను ఎంచుకుంటాము. ఇది మినీషిఫ్ట్ అని పిలువబడేది మరియు ఓపెన్‌షిఫ్ట్ ఆరిజిన్ ప్రాజెక్ట్‌పై ఆధారపడింది, కానీ ఇప్పుడు ఇది CRC మరియు Red Hat యొక్క OpenShift కంటైనర్ ప్లాట్‌ఫారమ్‌లో నిర్మించబడింది.
ఇక్కడ, క్షమించండి, మేము సహాయం చేయలేము: "OpenShift చాలా బాగుంది!"
ప్రారంభంలో, ఓపెన్‌షిఫ్ట్‌లో డెవలప్‌మెంట్ కుబెర్నెట్స్‌లో డెవలప్‌మెంట్‌కు భిన్నంగా లేదని వ్రాయాలని మేము అనుకున్నాము. మరియు నిజానికి, అది మార్గం. కానీ ఈ పోస్ట్ వ్రాసే ప్రక్రియలో, మీకు ఓపెన్‌షిఫ్ట్ లేనప్పుడు మీరు ఎన్ని అనవసరమైన కదలికలు చేయాలో మేము గుర్తుంచుకున్నాము మరియు అందువల్ల, మళ్ళీ, ఇది అందంగా ఉంది. మేము విషయాలు సులభంగా ఉండటాన్ని ఇష్టపడతాము మరియు minikubeతో పోలిస్తే OpenShiftలో మా ఉదాహరణను అమలు చేయడం మరియు అమలు చేయడం ఎంత సులభమో ఈ పోస్ట్ రాయడానికి మాకు ప్రేరణనిచ్చింది.
ప్రక్రియను అమలు చేసి, మనం ఏమి చేయాలో చూద్దాం.
కాబట్టి minikube ఉదాహరణలో, మేము డాకర్‌తో ప్రారంభించాము... వేచి ఉండండి, మాకు ఇకపై మెషీన్‌లో డాకర్ ఇన్‌స్టాల్ చేయవలసిన అవసరం లేదు.
మరియు మాకు స్థానిక git అవసరం లేదు.
మరియు మావెన్ అవసరం లేదు.
మరియు మీరు చేతితో కంటైనర్ చిత్రాన్ని సృష్టించాల్సిన అవసరం లేదు.
మరియు మీరు కంటైనర్ చిత్రాల రిపోజిటరీ కోసం వెతకవలసిన అవసరం లేదు.
మరియు మీరు ఇన్‌గ్రెస్ కంట్రోలర్‌ను ఇన్‌స్టాల్ చేయాల్సిన అవసరం లేదు.
మరియు మీరు ప్రవేశాన్ని కాన్ఫిగర్ చేయవలసిన అవసరం లేదు.
నీకు అర్ధమైనదా? OpenShiftలో మా అప్లికేషన్‌ని అమలు చేయడానికి మరియు అమలు చేయడానికి, పైన పేర్కొన్నవేవీ అవసరం లేదు. మరియు ప్రక్రియ కూడా క్రింది విధంగా ఉంటుంది.
దశ 1 - మీ ఓపెన్‌షిఫ్ట్ క్లస్టర్‌ను ప్రారంభించడం
మేము Red Hat నుండి కోడ్ రెడీ కంటైనర్‌లను ఉపయోగిస్తాము, ఇది తప్పనిసరిగా అదే Minikube, కానీ పూర్తి సింగిల్-నోడ్ Openshift క్లస్టర్‌తో మాత్రమే.
crc start
దశ 2 - ఓపెన్‌షిఫ్ట్ క్లస్టర్‌కి అప్లికేషన్‌ను రూపొందించండి మరియు అమలు చేయండి
ఈ దశలోనే OpenShift యొక్క సరళత మరియు సౌలభ్యం దాని గొప్పతనంలో వ్యక్తమవుతుంది. అన్ని Kubernetes పంపిణీల మాదిరిగానే, క్లస్టర్‌లో అప్లికేషన్‌ను అమలు చేయడానికి మాకు అనేక మార్గాలు ఉన్నాయి. మరియు, KUK విషయంలో వలె, మేము ప్రత్యేకంగా సరళమైనదాన్ని ఎంచుకుంటాము.
OpenShift ఎల్లప్పుడూ కంటైనర్ చేయబడిన అప్లికేషన్‌లను నిర్మించడానికి మరియు అమలు చేయడానికి ఒక వేదికగా నిర్మించబడింది. కంటైనర్‌లను నిర్మించడం ఎల్లప్పుడూ ఈ ప్లాట్‌ఫారమ్‌లో అంతర్భాగంగా ఉంది, కాబట్టి సంబంధిత పనుల కోసం అదనపు కుబెర్నెట్స్ వనరులు ఉన్నాయి.
మేము OpenShift యొక్క సోర్స్ 2 ఇమేజ్ (S2I) ప్రాసెస్‌ని ఉపయోగిస్తాము, ఇది మా మూలాన్ని (కోడ్ లేదా బైనరీలు) తీసుకోవడానికి మరియు దానిని OpenShift క్లస్టర్‌లో పనిచేసే కంటెయినరైజ్డ్ ఇమేజ్‌గా మార్చడానికి అనేక విభిన్న మార్గాలను కలిగి ఉంటుంది.
దీని కోసం మనకు రెండు విషయాలు అవసరం:
- git రిపోజిటరీలో మా సోర్స్ కోడ్
- బిల్డర్-ఇమేజ్, దీని ఆధారంగా అసెంబ్లీ నిర్వహించబడుతుంది.
Red Hat మరియు కమ్యూనిటీ ద్వారా నిర్వహించబడే అనేక చిత్రాలు ఉన్నాయి మరియు నేను Java అప్లికేషన్‌ను రూపొందిస్తున్నందున మేము OpenJDK ఇమేజ్‌ని ఉపయోగిస్తాము.
మీరు OpenShift డెవలపర్ గ్రాఫికల్ కన్సోల్ నుండి మరియు కమాండ్ లైన్ నుండి S2I బిల్డ్‌ను అమలు చేయవచ్చు. మేము కొత్త-యాప్ ఆదేశాన్ని ఉపయోగిస్తాము, బిల్డర్ ఇమేజ్ మరియు మా సోర్స్ కోడ్‌ను ఎక్కడ పొందాలో తెలియజేస్తాము.
oc new-app registry.access.redhat.com/ubi8/openjdk-11:latest~https://github.com/gcolman/quarkus-hello-world.git
అంతే, మా అప్లికేషన్ సృష్టించబడింది. అలా చేయడం ద్వారా, S2I ప్రక్రియ క్రింది పనులను చేసింది:
- అప్లికేషన్‌ను రూపొందించడానికి సంబంధించిన అన్ని రకాల విషయాల కోసం సర్వీస్ బిల్డ్-పాడ్‌ను రూపొందించారు.
- OpenShift బిల్డ్ కాన్ఫిగరేషన్ సృష్టించబడింది.
- నేను బిల్డర్ చిత్రాన్ని అంతర్గత OpenShift డాకర్ రిజిస్ట్రీకి డౌన్‌లోడ్ చేసాను.
- స్థానిక రిపోజిటరీకి "హలో వరల్డ్" క్లోన్ చేయబడింది.
- అక్కడ ఒక మావెన్ పోమ్ ఉంది మరియు మావెన్‌తో యాప్‌ను కంపైల్ చేసాను.
- కంపైల్ చేయబడిన జావా అప్లికేషన్‌ను కలిగి ఉన్న కొత్త కంటైనర్ ఇమేజ్‌ని సృష్టించి, ఈ ఇమేజ్‌ని అంతర్గత కంటైనర్ రిజిస్ట్రీలో ఉంచారు.
- పాడ్, సర్వీస్ మొదలైన వాటి కోసం స్పెసిఫికేషన్‌లతో కుబెర్నెట్స్ డిప్లాయ్‌మెంట్ సృష్టించబడింది.
- డిప్లాయ్ కంటైనర్ చిత్రం ప్రారంభించబడింది.
- సర్వీస్ బిల్డ్-పాడ్ తీసివేయబడింది.
ఈ జాబితాలో చాలా ఉన్నాయి, కానీ ప్రధాన విషయం ఏమిటంటే, మొత్తం బిల్డ్ ప్రత్యేకంగా ఓపెన్‌షిఫ్ట్ లోపల జరుగుతుంది, అంతర్గత డాకర్ రిజిస్ట్రీ ఓపెన్‌షిఫ్ట్ లోపల ఉంది మరియు బిల్డ్ ప్రాసెస్ అన్ని కుబెర్నెట్స్ భాగాలను సృష్టిస్తుంది మరియు వాటిని క్లస్టర్‌లో అమలు చేస్తుంది.
మీరు కన్సోల్‌లో S2I ప్రయోగాన్ని దృశ్యమానంగా పర్యవేక్షిస్తే, బిల్డ్ సమయంలో బిల్డ్ పాడ్ ఎలా ప్రారంభించబడుతుందో మీరు చూడవచ్చు.
మరియు ఇప్పుడు బిల్డర్ పాడ్ యొక్క లాగ్‌లను పరిశీలిద్దాం: ముందుగా, మా జావా అప్లికేషన్‌ను రూపొందించడానికి మావెన్ తన పనిని మరియు డౌన్‌లోడ్ డిపెండెన్సీలను ఎలా డౌన్‌లోడ్ చేస్తుందో అక్కడ మీరు చూడవచ్చు.
మావెన్ బిల్డ్ పూర్తయిన తర్వాత, కంటైనర్ ఇమేజ్ బిల్డ్ ప్రారంభించబడుతుంది, ఆపై ఈ బిల్ట్ ఇమేజ్ అంతర్గత రిపోజిటరీకి పంపబడుతుంది.
అంతా, అసెంబ్లీ ప్రక్రియ పూర్తయింది. ఇప్పుడు మన అప్లికేషన్ యొక్క పాడ్‌లు మరియు సేవలు క్లస్టర్‌లో ప్రారంభమయ్యాయని నిర్ధారించుకోండి.
oc get service
అంతే. మరియు ఒకే జట్టు ఉంది. మేము చేయాల్సిందల్లా ఈ సేవను బయటి యాక్సెస్ కోసం బహిర్గతం చేయడం.
దశ 3 - బయటి నుండి యాక్సెస్ కోసం సేవను బహిర్గతం చేయండి
KUC విషయంలో వలె, OpenShift ప్లాట్‌ఫారమ్‌లో క్లస్టర్‌లోని సేవకు బాహ్య ట్రాఫిక్‌ను మళ్లించడానికి మా “హలో వరల్డ్”కి కూడా రూటర్ అవసరం. OpenShift దీన్ని చాలా సులభం చేస్తుంది. ముందుగా, HAProxy రూటింగ్ భాగం డిఫాల్ట్‌గా క్లస్టర్‌లో ఇన్‌స్టాల్ చేయబడింది (దీనిని అదే NGINXకి మార్చవచ్చు). రెండవది, రూట్స్ అని పిలువబడే ప్రత్యేకమైన మరియు అత్యంత అనుకూలీకరించదగిన వనరులు ఉన్నాయి మరియు అవి మంచి పాత కుబెర్నెట్స్‌లోని ఇన్‌గ్రెస్ ఆబ్జెక్ట్‌లను పోలి ఉంటాయి (వాస్తవానికి, ఓపెన్‌షిఫ్ట్ రూట్‌లు ఇన్‌గ్రెస్ ఆబ్జెక్ట్‌ల రూపకల్పనను బాగా ప్రభావితం చేశాయి, వీటిని ఇప్పుడు ఓపెన్‌షిఫ్ట్‌లో ఉపయోగించవచ్చు) , కానీ మా “హలో వరల్డ్” కోసం , మరియు దాదాపు అన్ని ఇతర సందర్భాలలో, అదనపు కాన్ఫిగరేషన్ లేకుండా మాకు ప్రామాణిక రూట్ సరిపోతుంది.
“హలో వరల్డ్” కోసం రౌటబుల్ FQDNని సృష్టించడానికి (అవును, సర్వీస్ పేర్లతో రౌటింగ్ చేయడానికి OpenShiift దాని స్వంత DNSని కలిగి ఉంది), మేము మా సేవను బహిర్గతం చేస్తాము:
oc expose service quarkus-hello-world
మీరు కొత్తగా సృష్టించిన మార్గాన్ని చూస్తే, మీరు అక్కడ FQDN మరియు ఇతర రూటింగ్ సమాచారాన్ని కనుగొనవచ్చు:
oc get route
చివరకు, మేము బ్రౌజర్ నుండి మా సేవను యాక్సెస్ చేస్తాము:
కానీ ఇప్పుడు అది చాలా సులభం!
మేము కుబెర్నెట్‌లను మరియు ఈ సాంకేతికత మిమ్మల్ని అనుమతించే ప్రతిదాన్ని ప్రేమిస్తున్నాము మరియు మేము సరళత మరియు తేలికను కూడా ఇష్టపడతాము. Kubernetes పంపిణీ చేయబడిన, స్కేలబుల్ కంటైనర్‌లను ఆపరేట్ చేయడం చాలా సులభం చేయడానికి రూపొందించబడింది, అయితే ఈరోజు అప్లికేషన్‌లను ఉత్పత్తిలోకి తీసుకురావడానికి దాని సరళత సరిపోదు. ఇక్కడే OpenShift అమలులోకి వస్తుంది, సమయానికి అనుగుణంగా మరియు డెవలపర్-సెంట్రిక్ కుబెర్నెట్‌లను అందిస్తోంది. S2I, ODI, డెవలపర్ పోర్టల్, ఓపెన్‌షిఫ్ట్ ఆపరేటర్ ఫ్రేమ్‌వర్క్, IDE ఇంటిగ్రేషన్, డెవలపర్ కేటలాగ్‌లు, హెల్మ్ ఇంటిగ్రేషన్, మానిటరింగ్ మరియు అనేక ఇతర సాధనాల సృష్టితో సహా డెవలపర్ కోసం ప్రత్యేకంగా ఓపెన్‌షిఫ్ట్ ప్లాట్‌ఫారమ్‌ను రూపొందించడానికి చాలా కృషి పెట్టుబడి పెట్టబడింది.
ఈ వ్యాసం మీకు ఆసక్తికరంగా మరియు ఉపయోగకరంగా ఉందని మేము ఆశిస్తున్నాము. మరియు మీరు పోర్టల్‌లోని OpenShift ప్లాట్‌ఫారమ్‌లో అభివృద్ధి చేయడానికి ఉపయోగకరమైన అదనపు వనరులు, పదార్థాలు మరియు ఇతర విషయాలను కనుగొనవచ్చు .
మూలం: www.habr.com