ઓપનશિફ્ટ પર આધુનિક એપ્લિકેશન્સ, ભાગ 3: વિકાસ પર્યાવરણ તરીકે ઓપનશિફ્ટ અને ઓપનશિફ્ટ પાઇપલાઇન્સ

આ બ્લોગ પર દરેકને હેલો! આ શ્રેણીની ત્રીજી પોસ્ટ છે જેમાં અમે બતાવીએ છીએ કે Red Hat OpenShift પર આધુનિક વેબ એપ્લિકેશનો કેવી રીતે જમાવવી.

અગાઉની બે પોસ્ટ્સમાં, અમે બતાવ્યું કે આધુનિક વેબ એપ્લિકેશનને માત્ર થોડા પગલામાં કેવી રીતે જમાવવા અને નવી S2I ઇમેજનો ઉપયોગ કેવી રીતે કરવો તે સાથે ઑફ-ધ-શેલ્ફ HTTP સર્વર ઇમેજ, જેમ કે NGINX, ઉત્પાદન જમાવટને ગોઠવવા માટે સાંકળવાળા બિલ્ડ્સનો ઉપયોગ કરીને. .

આજે અમે ઓપનશિફ્ટ પ્લેટફોર્મ પર તમારી એપ્લિકેશન માટે ડેવલપમેન્ટ સર્વર કેવી રીતે ચલાવવું અને તેને સ્થાનિક ફાઇલ સિસ્ટમ સાથે સિંક્રનાઇઝ કરવું તે બતાવીશું, અને ઓપનશિફ્ટ પાઇપલાઇન્સ શું છે અને લિંક્ડ એસેમ્બલીઓના વિકલ્પ તરીકે તેનો ઉપયોગ કેવી રીતે કરી શકાય તે વિશે પણ વાત કરીશું.

વિકાસ પર્યાવરણ તરીકે OpenShift

વિકાસ કાર્યપ્રવાહ

પહેલાથી જ જણાવ્યું તેમ પ્રથમ પોસ્ટ, આધુનિક વેબ એપ્લીકેશનો માટેની લાક્ષણિક વિકાસ પ્રક્રિયા એ અમુક પ્રકારનું "વિકાસ સર્વર" છે જે સ્થાનિક ફાઇલોમાં થતા ફેરફારોને ટ્રેક કરે છે. જ્યારે તે થાય છે, ત્યારે એપ્લિકેશન બિલ્ડ ટ્રિગર થાય છે અને પછી તે બ્રાઉઝર પર અપડેટ થાય છે.

મોટાભાગના આધુનિક ફ્રેમવર્કમાં, આવા "વિકાસ સર્વર" અનુરૂપ કમાન્ડ લાઇન ટૂલ્સમાં બનેલ છે.

સ્થાનિક ઉદાહરણ

સૌપ્રથમ, ચાલો જોઈએ કે સ્થાનિક રીતે એપ્લીકેશન ચલાવતી વખતે આ કેવી રીતે કાર્ય કરે છે. ચાલો એક ઉદાહરણ તરીકે એપ્લિકેશન લઈએ પ્રતિક્રિયા અગાઉના લેખોમાંથી, જોકે લગભગ સમાન વર્કફ્લો ખ્યાલો અન્ય તમામ આધુનિક ફ્રેમવર્કમાં લાગુ પડે છે.
તેથી, અમારા પ્રતિક્રિયા ઉદાહરણમાં "દેવ સર્વર" શરૂ કરવા માટે, અમે નીચેનો આદેશ દાખલ કરીશું:

$ npm run start

પછી ટર્મિનલ વિન્ડોમાં આપણે આના જેવું કંઈક જોશું:

અને અમારી એપ્લિકેશન ડિફોલ્ટ બ્રાઉઝરમાં ખુલશે:

હવે, જો આપણે ફાઇલમાં ફેરફાર કરીએ, તો એપ્લિકેશન બ્રાઉઝરમાં અપડેટ થવી જોઈએ.

ઠીક છે, સ્થાનિક મોડમાં વિકાસ સાથે બધું સ્પષ્ટ છે, પરંતુ OpenShift પર તે કેવી રીતે પ્રાપ્ત કરવું?

OpenShift પર વિકાસ સર્વર

જો તમને યાદ છે, માં અગાઉની પોસ્ટ, અમે S2I ઇમેજના કહેવાતા રન તબક્કાને જોયો અને જોયું કે ડિફૉલ્ટ રૂપે, સર્વ મોડ્યુલ અમારી વેબ એપ્લિકેશનને સર્વિસ કરવા માટે જવાબદાર છે.

જો કે, જો તમે નજીકથી જુઓ સ્ક્રિપ્ટ ચલાવો તે ઉદાહરણમાંથી, તે $NPM_RUN પર્યાવરણ ચલ ધરાવે છે, જે તમને તમારા આદેશને ચલાવવા માટે પરવાનગી આપે છે.

ઉદાહરણ તરીકે, અમે અમારી એપ્લિકેશનનો ઉપયોગ કરવા માટે નોડશિફ્ટ મોડ્યુલનો ઉપયોગ કરી શકીએ છીએ:

$ npx nodeshift --deploy.env NPM_RUN="yarn start" --dockerImage=nodeshift/ubi8-s2i-web-app

નોંધ: ઉપરોક્ત ઉદાહરણ સામાન્ય વિચારને સમજાવવા માટે સંક્ષિપ્ત છે.

અહીં અમે અમારા જમાવટમાં NPM_RUN પર્યાવરણ વેરીએબલ ઉમેર્યું છે, જે યાર્ન સ્ટાર્ટ કમાન્ડ ચલાવવા માટે રનટાઇમ કહે છે, જે અમારા ઓપનશિફ્ટ પોડની અંદર રિએક્ટ ડેવલપમેન્ટ સર્વરને શરૂ કરે છે.

જો તમે ચાલતા પોડના લોગને જોશો, તો તે કંઈક આના જેવું દેખાશે:

અલબત્ત, જ્યાં સુધી આપણે સ્થાનિક કોડને કોડ સાથે સિંક્રનાઇઝ ન કરી શકીએ ત્યાં સુધી આ બધું કંઈ હશે, જે ફેરફારો માટે પણ મોનિટર કરવામાં આવે છે, પરંતુ રિમોટ સર્વર પર રહે છે.

રિમોટ અને લોકલ કોડને સિંક્રનાઇઝ કરી રહ્યા છીએ

સદનસીબે, નોડશિફ્ટ સરળતાથી સિંક્રનાઇઝેશનમાં મદદ કરી શકે છે, અને તમે ફેરફારોને ટ્રૅક કરવા માટે વૉચ કમાન્ડનો ઉપયોગ કરી શકો છો.

તેથી અમે અમારી એપ્લિકેશન માટે ડેવલપમેન્ટ સર્વરને જમાવવા માટે આદેશ ચલાવ્યા પછી, અમે નીચેના આદેશનો સુરક્ષિત રીતે ઉપયોગ કરી શકીએ છીએ:

$ npx nodeshift watch

પરિણામે, અમે થોડા સમય પહેલા બનાવેલા ચાલી રહેલા પોડ સાથે કનેક્શન બનાવવામાં આવશે, રિમોટ ક્લસ્ટર સાથે અમારી સ્થાનિક ફાઇલોનું સિંક્રનાઇઝેશન સક્રિય થશે, અને અમારી સ્થાનિક સિસ્ટમ પરની ફાઇલોને ફેરફારો માટે મોનિટર કરવાનું શરૂ થશે.

તેથી, જો આપણે હવે src/App.js ફાઇલને અપડેટ કરીશું, તો સિસ્ટમ આ ફેરફારો પર પ્રતિક્રિયા આપશે, તેને રિમોટ ક્લસ્ટરમાં કૉપિ કરશે અને ડેવલપમેન્ટ સર્વર શરૂ કરશે, જે પછી બ્રાઉઝરમાં અમારી એપ્લિકેશનને અપડેટ કરશે.

ચિત્ર પૂર્ણ કરવા માટે, ચાલો બતાવીએ કે આ સમગ્ર આદેશો કેવા દેખાય છે:

$ npx nodeshift --strictSSL=false --dockerImage=nodeshift/ubi8-s2i-web-app --build.env YARN_ENABLED=true --expose --deploy.env NPM_RUN="yarn start" --deploy.port 3000

$ npx nodeshift watch --strictSSL=false

વોચ કમાન્ડ એ oc rsync આદેશની ટોચ પર એક એબ્સ્ટ્રેક્શન છે, તમે તે કેવી રીતે કાર્ય કરે છે તે વિશે વધુ જાણી શકો છો અહીં.

આ પ્રતિક્રિયા માટેનું ઉદાહરણ હતું, પરંતુ ચોક્કસ સમાન પદ્ધતિનો ઉપયોગ અન્ય ફ્રેમવર્ક સાથે કરી શકાય છે, ફક્ત NPM_RUN પર્યાવરણ ચલને જરૂરી તરીકે સેટ કરો.
 

ઓપનશિફ્ટ પાઇપલાઇન્સ

આગળ આપણે ઓપનશિફ્ટ પાઇપલાઇન્સ જેવા ટૂલ વિશે વાત કરીશું અને તેને સાંકળો બાંધવાના વિકલ્પ તરીકે કેવી રીતે વાપરી શકાય છે.

ઓપનશિફ્ટ પાઇપલાઇન્સ શું છે

OpenShift Pipelines એ ક્લાઉડ-નેટિવ CI/CD સતત એકીકરણ અને ડિલિવરી સિસ્ટમ છે જે ટેકટનનો ઉપયોગ કરીને પાઇપલાઇન્સ ગોઠવવા માટે રચાયેલ છે. ટેકટન એ લવચીક ઓપન-સોર્સ કુબરનેટ્સ-નેટિવ CI/CD ફ્રેમવર્ક છે જે તમને અંતર્ગત સ્તરમાંથી અમૂર્ત કરીને વિવિધ પ્લેટફોર્મ્સ (કુબરનેટ્સ, સર્વરલેસ, વર્ચ્યુઅલ મશીનો, વગેરે) પર જમાવટને સ્વચાલિત કરવાની મંજૂરી આપે છે.

આ લેખને સમજવા માટે પાઇપલાઇન્સનું થોડું જ્ઞાન જરૂરી છે, તેથી અમે ભારપૂર્વક ભલામણ કરીએ છીએ કે તમે પહેલા વાંચો સત્તાવાર પાઠયપુસ્તક.

તમારા કામનું વાતાવરણ ગોઠવી રહ્યું છે

આ લેખમાંના ઉદાહરણો સાથે રમવા માટે, તમારે પહેલા તમારા કાર્યકારી વાતાવરણને તૈયાર કરવાની જરૂર છે:

1. ઓપનશિફ્ટ 4 ક્લસ્ટર ઇન્સ્ટોલ અને ગોઠવો. અમારા ઉદાહરણો આ માટે કોડરેડી કન્ટેનર (સીઆરડી) નો ઉપયોગ કરે છે, જેના માટે ઇન્સ્ટોલેશન સૂચનાઓ મળી શકે છે. અહીં.
2. ક્લસ્ટર તૈયાર થયા પછી, તમારે તેના પર પાઇપલાઇન ઑપરેટર ઇન્સ્ટોલ કરવાની જરૂર છે. ડરશો નહીં, તે સરળ છે, ઇન્સ્ટોલેશન સૂચનાઓ અહીં.
3. ડાઉનલોડ ટેકટન CLI (tkn) અહીં.
4. એક એપ્લિકેશન બનાવવા માટે Create-react-app કમાન્ડ લાઇન ટૂલ ચલાવો જે તમે પછી જમાવશો (આ એક સરળ એપ્લિકેશન છે પ્રતિક્રિયા).
5. (વૈકલ્પિક) npm ઇન્સ્ટોલ અને પછી npm પ્રારંભ સાથે સ્થાનિક રીતે ઉદાહરણ એપ્લિકેશન ચલાવવા માટે રીપોઝીટરીને ક્લોન કરો.

એપ્લિકેશન રીપોઝીટરીમાં એક k8s ફોલ્ડર પણ હશે, જેમાં એપ્લિકેશનને જમાવવા માટે ઉપયોગમાં લેવાતા Kubernetes/OpenShift YAMLs હશે. ત્યાં કાર્યો, ક્લસ્ટર ટાસ્ક, સંસાધનો અને પાઇપલાઇન્સ હશે જે આપણે આમાં બનાવીશું ભંડાર.

ચાલો, શરુ કરીએ

અમારા ઉદાહરણ માટે પ્રથમ પગલું એ OpenShift ક્લસ્ટરમાં એક નવો પ્રોજેક્ટ બનાવવાનું છે. ચાલો આ પ્રોજેક્ટને વેબએપ-પાઈપલાઈન કહીએ અને તેને નીચેના આદેશથી બનાવીએ:

$ oc new-project webapp-pipeline

આ પ્રોજેક્ટનું નામ પછીથી કોડમાં દેખાશે, તેથી જો તમે તેને કંઈક બીજું નામ આપવાનું નક્કી કરો છો, તો તે મુજબ ઉદાહરણ કોડમાં ફેરફાર કરવાનું ભૂલશો નહીં. આ બિંદુથી શરૂ કરીને, આપણે ઉપર-નીચે નહીં, પરંતુ નીચે-ઉપર જઈશું: એટલે કે, આપણે પહેલા કન્વેયરના તમામ ઘટકો બનાવીશું, અને તે પછી જ કન્વેયર પોતે.

તેથી, સૌ પ્રથમ ...

કાર્યો

ચાલો કેટલાક કાર્યો બનાવીએ, જે પછી અમારી પાઇપલાઇનમાં એપ્લિકેશનને જમાવવામાં મદદ કરશે. પ્રથમ કાર્ય - apply_manifests_task - અમારી એપ્લિકેશનના k8s ફોલ્ડરમાં સ્થિત કુબરનેટ્સ સંસાધનો (સેવા, જમાવટ અને માર્ગ) ના YAML લાગુ કરવા માટે જવાબદાર છે. બીજું કાર્ય - અપડેટ_ડિપ્લોયમેન્ટ_ટાસ્ક - અમારી પાઇપલાઇન દ્વારા બનાવેલ છબી પર પહેલાથી જ જમાવવામાં આવેલી છબીને અપડેટ કરવા માટે જવાબદાર છે.

ચિંતા કરશો નહીં જો તે હજુ સુધી ખૂબ સ્પષ્ટ નથી. વાસ્તવમાં, આ કાર્યો ઉપયોગિતાઓ જેવા છે, અને અમે તેમને થોડી વાર પછી વધુ વિગતવાર જોઈશું. હમણાં માટે, ચાલો તેમને બનાવીએ:

$ oc create -f https://raw.githubusercontent.com/nodeshift/webapp-pipeline-tutorial/master/tasks/update_deployment_task.yaml
$ oc create -f https://raw.githubusercontent.com/nodeshift/webapp-pipeline-tutorial/master/tasks/apply_manifests_task.yaml

પછી, tkn CLI આદેશનો ઉપયોગ કરીને, અમે તપાસ કરીશું કે કાર્યો બનાવવામાં આવ્યા છે:

$ tkn task ls

NAME                AGE
apply-manifests     1 minute ago
update-deployment   1 minute ago

નોંધ: આ તમારા વર્તમાન પ્રોજેક્ટ માટે સ્થાનિક કાર્યો છે.

ક્લસ્ટર કાર્યો

ક્લસ્ટર કાર્યો મૂળભૂત રીતે સરળ કાર્યો જેવા જ છે. એટલે કે, તે પગલાંઓનો પુનઃઉપયોગ કરી શકાય તેવો સંગ્રહ છે જે ચોક્કસ કાર્ય ચલાવતી વખતે એક અથવા બીજી રીતે જોડવામાં આવે છે. તફાવત એ છે કે ક્લસ્ટર કાર્ય ક્લસ્ટરની અંદર દરેક જગ્યાએ ઉપલબ્ધ છે. પાઈપલાઈન ઓપરેટર ઉમેરતી વખતે આપમેળે બનેલા ક્લસ્ટર કાર્યોની યાદી જોવા માટે, અમે ફરીથી tkn CLI આદેશનો ઉપયોગ કરીશું:

$ tkn clustertask ls

NAME                       AGE
buildah                    1 day ago
buildah-v0-10-0            1 day ago
jib-maven                  1 day ago
kn                         1 day ago
maven                      1 day ago
openshift-client           1 day ago
openshift-client-v0-10-0   1 day ago
s2i                        1 day ago
s2i-go                     1 day ago
s2i-go-v0-10-0             1 day ago
s2i-java-11                1 day ago
s2i-java-11-v0-10-0        1 day ago
s2i-java-8                 1 day ago
s2i-java-8-v0-10-0         1 day ago
s2i-nodejs                 1 day ago
s2i-nodejs-v0-10-0         1 day ago
s2i-perl                   1 day ago
s2i-perl-v0-10-0           1 day ago
s2i-php                    1 day ago
s2i-php-v0-10-0            1 day ago
s2i-python-3               1 day ago
s2i-python-3-v0-10-0       1 day ago
s2i-ruby                   1 day ago
s2i-ruby-v0-10-0           1 day ago
s2i-v0-10-0                1 day ago

હવે ચાલો બે ક્લસ્ટર કાર્યો બનાવીએ. પ્રથમ S2I ઇમેજ જનરેટ કરશે અને તેને આંતરિક OpenShift રજિસ્ટ્રીમાં મોકલશે; બીજું અમે સામગ્રી તરીકે પહેલેથી જ બનાવેલ એપ્લિકેશનનો ઉપયોગ કરીને NGINX પર આધારિત અમારી છબી બનાવવાની છે.

છબી બનાવો અને મોકલો

પ્રથમ કાર્ય બનાવતી વખતે, અમે લિંક કરેલ એસેમ્બલી વિશે અગાઉના લેખમાં જે કર્યું છે તેનું પુનરાવર્તન કરીશું. યાદ કરો કે અમે અમારી એપ્લિકેશન "બિલ્ડ" કરવા માટે S2I ઇમેજ (ubi8-s2i-web-app) નો ઉપયોગ કર્યો હતો, અને OpenShift આંતરિક રજિસ્ટ્રીમાં સંગ્રહિત છબી સાથે અંત આવ્યો હતો. હવે અમે અમારી એપ માટે ડોકરફાઇલ બનાવવા માટે આ S2I વેબ એપ્લિકેશન ઇમેજનો ઉપયોગ કરીશું અને પછી વાસ્તવિક બિલ્ડ કરવા માટે Buildah નો ઉપયોગ કરીશું અને પરિણામી ઇમેજને OpenShift ઇન્ટરનલ રજિસ્ટ્રીમાં ધકેલીશું, કારણ કે જ્યારે તમે NodeShift નો ઉપયોગ કરીને તમારી એપ્લિકેશનો જમાવશો ત્યારે OpenShift તે જ કરે છે. .

અમને આ બધું કેવી રીતે ખબર પડી, તમે પૂછો છો? થી સત્તાવાર Node.js નું સત્તાવાર સંસ્કરણ, અમે હમણાં જ તેની નકલ કરી છે અને તેને આપણા માટે સંશોધિત કરી છે.

તો, ચાલો હવે s2i-web-app ક્લસ્ટર ટાસ્ક બનાવીએ:

$ oc create -f https://raw.githubusercontent.com/nodeshift/webapp-pipeline-tutorial/master/clustertasks/s2i-web-app-task.yaml

અમે આનું વિગતવાર વિશ્લેષણ કરીશું નહીં, પરંતુ માત્ર OUTPUT_DIR પેરામીટર પર ધ્યાન કેન્દ્રિત કરીશું:

params:
      - name: OUTPUT_DIR
        description: The location of the build output directory
        default: build

મૂળભૂત રીતે, આ પરિમાણ બિલ્ડ કરવા સમાન છે, જ્યાં પ્રતિક્રિયા એસેમ્બલ સામગ્રી મૂકે છે. અન્ય ફ્રેમવર્ક વિવિધ પાથનો ઉપયોગ કરે છે, ઉદાહરણ તરીકે, એમ્બરમાં તે ડિસ્ટ છે. અમારા પ્રથમ ક્લસ્ટર કાર્યનું આઉટપુટ અમે એકત્રિત કરેલ HTML, JavaScript અને CSS ધરાવતી છબી હશે.

NGINX પર આધારિત છબી બનાવો

અમારા બીજા ક્લસ્ટર કાર્યની વાત કરીએ તો, અમે પહેલેથી જ બનાવેલ એપ્લિકેશનની સામગ્રીનો ઉપયોગ કરીને, તેણે અમારા માટે NGINX-આધારિત છબી બનાવવી જોઈએ. અનિવાર્યપણે, આ પાછલા વિભાગનો ભાગ છે જ્યાં આપણે સાંકળવાળા બિલ્ડ્સ પર જોયું.

આ કરવા માટે, અમે - ઉપરની જેમ જ - એક ક્લસ્ટર કાર્ય webapp-build-runtime બનાવીશું:

$ oc create -f https://raw.githubusercontent.com/nodeshift/webapp-pipeline-tutorial/master/clustertasks/webapp-build-runtime-task.yaml

જો તમે આ ક્લસ્ટર કાર્યોના કોડને જોશો, તો તમે જોઈ શકો છો કે તે Git રિપોઝીટરી સાથે અમે કામ કરી રહ્યા છીએ અથવા અમે જે ઈમેજો બનાવી રહ્યા છીએ તેના નામનો ઉલ્લેખ કરતું નથી. અમે ફક્ત સ્પષ્ટ કરીએ છીએ કે અમે Git પર શું સ્થાનાંતરિત કરી રહ્યા છીએ, અથવા ચોક્કસ છબી જ્યાં અંતિમ છબી આઉટપુટ હોવી જોઈએ. તેથી જ અન્ય એપ્લિકેશનો સાથે કામ કરતી વખતે આ ક્લસ્ટર કાર્યોનો ફરીથી ઉપયોગ કરી શકાય છે.

અને અહીં અમે આકર્ષક રીતે આગળના મુદ્દા પર આગળ વધીએ છીએ...

સંપત્તિ

તેથી, કારણ કે, અમે હમણાં કહ્યું તેમ, ક્લસ્ટર કાર્યો શક્ય તેટલા સામાન્ય હોવા જોઈએ, અમારે એવા સંસાધનો બનાવવાની જરૂર છે જેનો ઉપયોગ ઇનપુટ (ગીટ રીપોઝીટરી) અને આઉટપુટ (અંતિમ છબીઓ) તરીકે થશે. અમને જે પ્રથમ સંસાધનની જરૂર છે તે ગિટ છે, જ્યાં અમારી એપ્લિકેશન રહે છે, કંઈક આના જેવું:

# This resource is the location of the git repo with the web application source
apiVersion: tekton.dev/v1alpha1
kind: PipelineResource
metadata:
  name: web-application-repo
spec:
  type: git
  params:
    - name: url
      value: https://github.com/nodeshift-starters/react-pipeline-example
    - name: revision
      value: master

અહીં PipelineResource git પ્રકારનું છે. params વિભાગમાં url કી ચોક્કસ રીપોઝીટરી તરફ નિર્દેશ કરે છે અને મુખ્ય શાખાને સ્પષ્ટ કરે છે (આ વૈકલ્પિક છે, પરંતુ અમે તેને પૂર્ણતા માટે લખીએ છીએ).

હવે આપણે ઇમેજ માટે એક સંસાધન બનાવવાની જરૂર છે જ્યાં s2i-web-app કાર્યના પરિણામો સાચવવામાં આવશે, આ આ રીતે કરવામાં આવે છે:

# This resource is the result of running "npm run build",  the resulting built files will be located in /opt/app-root/output
apiVersion: tekton.dev/v1alpha1
kind: PipelineResource
metadata:
  name: built-web-application-image
spec:
  type: image
  params:
    - name: url
      value: image-registry.openshift-image-registry.svc:5000/webapp-pipeline/built-web-application:latest

અહીં PipelineResource ઈમેજ પ્રકારનું છે, અને url પેરામીટરનું મૂલ્ય આંતરિક OpenShift ઈમેજ રજિસ્ટ્રી તરફ નિર્દેશ કરે છે, ખાસ કરીને વેબએપ-પાઈપલાઈન નેમસ્પેસમાં સ્થિત છે. જો તમે કોઈ અલગ નેમસ્પેસનો ઉપયોગ કરી રહ્યાં હોવ તો આ સેટિંગ બદલવાનું ભૂલશો નહીં.

અને છેલ્લે, અમને જે છેલ્લું સંસાધન જોઈએ છે તે પણ પ્રકારની ઈમેજનું હશે અને આ અંતિમ NGINX ઈમેજ હશે જેનો ઉપયોગ પછી જમાવટ દરમિયાન કરવામાં આવશે:

# This resource is the image that will be just the static html, css, js files being run with nginx
apiVersion: tekton.dev/v1alpha1
kind: PipelineResource
metadata:
  name: runtime-web-application-image
spec:
  type: image
  params:
    - name: url
      value: image-registry.openshift-image-registry.svc:5000/webapp-pipeline/runtime-web-application:latest

ફરીથી, નોંધ લો કે આ સંસાધન વેબએપ-પાઇપલાઇન નેમસ્પેસમાં આંતરિક OpenShift રજિસ્ટ્રીમાં છબીને સંગ્રહિત કરે છે.

આ બધા સંસાધનો એકસાથે બનાવવા માટે, અમે create આદેશનો ઉપયોગ કરીએ છીએ:

$ oc create -f https://raw.githubusercontent.com/nodeshift/webapp-pipeline-tutorial/master/resources/resource.yaml

તમે ખાતરી કરી શકો છો કે સંસાધનો આ રીતે બનાવવામાં આવ્યા છે:

$ tkn resource ls

કન્વેયર પાઇપલાઇન

હવે અમારી પાસે બધા જરૂરી ઘટકો છે, ચાલો નીચે આપેલા આદેશ સાથે તેને બનાવીને તેમાંથી પાઇપલાઇન એસેમ્બલ કરીએ:

$ oc create -f https://raw.githubusercontent.com/nodeshift/webapp-pipeline-tutorial/master/pipelines/build-and-deploy-react.yaml

પરંતુ આ આદેશ ચલાવતા પહેલા, ચાલો આ ઘટકો જોઈએ. પ્રથમ નામ છે:

apiVersion: tekton.dev/v1alpha1
kind: Pipeline
metadata:
  name: build-and-deploy-react

પછી સ્પેક વિભાગમાં આપણે અગાઉ બનાવેલા સંસાધનોનો સંકેત જોઈએ છીએ:

spec:
  resources:
    - name: web-application-repo
      type: git
    - name: built-web-application-image
      type: image
    - name: runtime-web-application-image
      type: image

પછી અમે એવા કાર્યો બનાવીએ છીએ જે અમારી પાઇપલાઇનને પૂર્ણ કરવાની જરૂર છે. સૌ પ્રથમ, તે s2i-web-app કાર્યને અમલમાં મૂકવું જોઈએ જે અમે પહેલેથી જ બનાવેલ છે:

tasks:
    - name: build-web-application
      taskRef:
        name: s2i-web-app
        kind: ClusterTask

આ કાર્ય ઇનપુટ (ગીર સંસાધન) અને આઉટપુટ (બિલ્ટ-વેબ-એપ્લિકેશન-ઇમેજ રિસોર્સ) પરિમાણો લે છે. અમે તેને એક વિશિષ્ટ પરિમાણ પણ પસાર કરીએ છીએ જેથી કરીને તે TLS ની ચકાસણી ન કરે કારણ કે અમે સ્વ-સહી કરેલ પ્રમાણપત્રોનો ઉપયોગ કરી રહ્યા છીએ:

resources:
        inputs:
          - name: source
            resource: web-application-repo
        outputs:
          - name: image
            resource: built-web-application-image
      params:
        - name: TLSVERIFY
          value: "false"

આગળનું કાર્ય લગભગ સરખું જ છે, ફક્ત અહીં વેબએપ-બિલ્ડ-રનટાઇમ ક્લસ્ટર કાર્ય જે આપણે પહેલાથી જ બનાવેલ છે તેને કહેવામાં આવે છે:

name: build-runtime-image
    taskRef:
      name: webapp-build-runtime
      kind: ClusterTask

અગાઉના કાર્યની જેમ, અમે સંસાધનમાં પસાર કરીએ છીએ, પરંતુ હવે તે બિલ્ટ-વેબ-એપ્લિકેશન-ઇમેજ (અમારા અગાઉના કાર્યનું આઉટપુટ) છે. અને આઉટપુટ તરીકે આપણે ફરીથી ઈમેજ સેટ કરીએ છીએ. કારણ કે આ કાર્ય પાછલા એક પછી ચલાવવામાં આવવું જોઈએ, અમે રનઆફ્ટર ફીલ્ડ ઉમેરીએ છીએ:

resources:
        inputs:
          - name: image
            resource: built-web-application-image
        outputs:
          - name: image
            resource: runtime-web-application-image
        params:
        - name: TLSVERIFY
          value: "false"
      runAfter:
        - build-web-application

અમારી વેબ એપ્લિકેશનની k8s ડિરેક્ટરીમાં રહેતી સેવા, રૂટ અને ડિપ્લોયમેન્ટ YAML ફાઈલોનો ઉપયોગ કરવા માટે અને નવી ઈમેજો બનાવતી વખતે આ જમાવટને અપડેટ કરવા માટે પણ આગામી બે કાર્યો જવાબદાર છે. અમે લેખની શરૂઆતમાં આ બે ક્લસ્ટર કાર્યોને વ્યાખ્યાયિત કર્યા છે.

કન્વેયર શરૂ કરી રહ્યા છીએ

તેથી, અમારી પાઇપલાઇનના તમામ ભાગો બનાવવામાં આવ્યા છે, અને અમે તેને નીચેના આદેશથી ચલાવીશું:

$ tkn pipeline start build-and-deploy-react

આ તબક્કે, આદેશ વાક્યનો અરસપરસ ઉપયોગ થાય છે અને તમારે તેની દરેક વિનંતીના જવાબમાં યોગ્ય સંસાધનો પસંદ કરવાની જરૂર છે: ગિટ સંસાધન માટે, વેબ-એપ્લિકેશન-રેપો પસંદ કરો, પછી પ્રથમ છબી સંસાધન માટે, બિલ્ટ-વેબ-એપ્લિકેશન -ઇમેજ, અને અંતે, બીજા ઇમેજ રિસોર્સ માટે -રનટાઇમ-વેબ-એપ્લિકેશન-ઇમેજ:

? Choose the git resource to use for web-application-repo: web-application-repo (https://github.com/nodeshift-starters/react-pipeline-example)
? Choose the image resource to use for built-web-application-image: built-web-application-image (image-registry.openshift-image-registry.svc:5000/webapp-pipeline/built-web-
application:latest)
? Choose the image resource to use for runtime-web-application-image: runtime-web-application-image (image-registry.openshift-image-registry.svc:5000/webapp-pipeline/runtim
e-web-application:latest)
Pipelinerun started: build-and-deploy-react-run-4xwsr

હવે ચાલો નીચેના આદેશનો ઉપયોગ કરીને પાઇપલાઇનની સ્થિતિ તપાસીએ:

$ tkn pipeline logs -f

એકવાર પાઇપલાઇન શરૂ થઈ જાય અને એપ્લિકેશન તૈનાત થઈ જાય, અમે નીચેના આદેશ સાથે પ્રકાશિત માર્ગની વિનંતી કરી શકીએ છીએ:

$ oc get route react-pipeline-example --template='http://{{.spec.host}}'

વધુ વિઝ્યુલાઇઝેશન માટે, તમે વિભાગમાં વેબ કન્સોલના ડેવલપર મોડમાં અમારી પાઇપલાઇન જોઈ શકો છો પાઇપલાઇન્સ, ફિગ માં બતાવ્યા પ્રમાણે. 1.

ફિગ.1. ચાલી રહેલ પાઇપલાઇન્સની સમીક્ષા.

ચાલતી પાઇપલાઇન પર ક્લિક કરવાથી વધારાની વિગતો પ્રદર્શિત થાય છે, જેમ કે આકૃતિ 2 માં બતાવેલ છે.

ચોખા. 2. પાઇપલાઇન વિશે વધારાની માહિતી.

વધુ માહિતી પછી, તમે વ્યુમાં ચાલી રહેલી એપ્લિકેશનો જોઈ શકો છો ટોપોલોજી, Fig.3 માં બતાવ્યા પ્રમાણે.

ફિગ 3. લોંચ કરેલ પોડ.

ચિહ્નના ઉપરના જમણા ખૂણામાં વર્તુળ પર ક્લિક કરવાથી અમારી એપ્લિકેશન ખુલે છે, જેમ કે ફિગ. 4 માં બતાવ્યા પ્રમાણે.

ચોખા. 4. રિએક્ટ એપ્લિકેશન ચલાવવી.

નિષ્કર્ષ

તેથી, અમે OpenShift પર તમારી એપ્લિકેશન માટે ડેવલપમેન્ટ સર્વર કેવી રીતે ચલાવવું અને તેને સ્થાનિક ફાઇલ સિસ્ટમ સાથે સિંક્રનાઇઝ કરવું તે બતાવ્યું. અમે ઓપનશિફ્ટ પાઇપલાઇન્સનો ઉપયોગ કરીને ચેઇન-બિલ્ડ ટેમ્પલેટનું અનુકરણ કેવી રીતે કરવું તે પણ જોયું. આ લેખમાંથી તમામ ઉદાહરણ કોડ મળી શકે છે અહીં.

વધારાના સંસાધનો (EN)

• મફત ઈ-બુક "ઓપનશિફ્ટ પર વિકાસ: ઉત્સુક માટે માર્ગદર્શિકા"
• Red Hat OpenShift એપ્લિકેશન રનટાઇમ અને Istio નો ઉપયોગ કરીને કન્ટેનર-સેન્ટ્રીક Node.js એપ્લીકેશનો બનાવવી
• Chrome DevTools નો ઉપયોગ કરીને OpenShift પર Node.js એપ્લિકેશનને ડીબગ કરવું
• ઓપનશિફ્ટ પર એક્સપ્રેસને શરૂઆતથી માસ્ટર કરવા માટે ત્રણ આદેશો
• Red Hat OpenShift એપ્લિકેશન રનટાઇમના ભાગ રૂપે Node.js ના સામાન્ય રીતે ઉપલબ્ધ સંસ્કરણની જાહેરાત
• Prometheus સાથે OpenShift પર Node.js એપ્લીકેશનનું મોનિટરિંગ
• પર અન્ય લેખો OpenShift અને Kubernetes Red Hat વેબસાઇટ પર

આગામી વેબિનારની જાહેરાત

અમે Red Hat OpenShift કન્ટેનર પ્લેટફોર્મ અને કુબરનેટ્સનો ઉપયોગ કરીને મૂળ અનુભવ વિશે શુક્રવારના વેબિનર્સની શ્રેણી શરૂ કરી રહ્યા છીએ:

• ઑગસ્ટ 28, વેબિનર સમ્રાટ "ઑપરેટર": ઓપનશિફ્ટ અને કુબરનેટ્સમાં ઑપરેટર્સ
• સપ્ટેમ્બર 11, ડિપ્લોયમેન્ટ કોન્ફિગ વિ ડિપ્લોયમેન્ટ - એપ્લિકેશન બનાવવા અને જમાવટ કરવા માટે ઓપનશિફ્ટ-વિશિષ્ટ જાદુ
• સપ્ટેમ્બર 25, Red Hat OpenShift અને Machine API
• ઑક્ટોબર 9, કામના બોજમાં અચાનક વધારો થવાનો સામનો કેવી રીતે કરવો
• ઑક્ટોબર 23, રેડ હેટ ઓપનશિફ્ટ કન્ટેનર પ્લેટફોર્મમાં એમ્બેડેડ જેનકિન્સ, પાઇપલાઇન-બિલ્ડ્સ, ટેકટન

સોર્સ: www.habr.com