અમે પ્લગઇન્સ, SMS અથવા નોંધણી વિના GKE માં જમાવટ કાર્ય બનાવીએ છીએ. ચાલો જેનકિન્સના જેકેટની નીચે એક નજર કરીએ

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

મારે કબૂલ કરવું જોઈએ, હું એકદમ આળસુ છું (શું મેં આ અગાઉ સ્વીકાર્યું ન હતું? ના?), અને એ હકીકતને ધ્યાનમાં રાખીને કે ટીમ લીડ્સને જેનકિન્સ સુધી પહોંચવાની જરૂર છે, જેમાં અમારી પાસે તમામ CI/CD છે, મેં વિચાર્યું: તેને તૈનાત કરવા દો જેટલું તે ઇચ્છે છે! મને એક મજાક યાદ આવી: એક માણસને માછલી આપો અને તે એક દિવસ ખાશે; વ્યક્તિને ફેડ કહો અને તેને આખી જીંદગી ફેડ કરવામાં આવશે. અને ગયો કામ પર યુક્તિઓ રમો, જે કુબેરમાં કોઈપણ સફળતાપૂર્વક બિલ્ટ વર્ઝનની એપ્લિકેશન ધરાવતું કન્ટેનર તૈનાત કરી શકશે અને તેમાં કોઈપણ મૂલ્યો ટ્રાન્સફર કરી શકશે. ENV (મારા દાદા, એક ફિલોલોજિસ્ટ, ભૂતકાળમાં અંગ્રેજી શિક્ષક, હવે આ વાક્ય વાંચ્યા પછી તેમના મંદિરમાં તેમની આંગળી ફેરવશે અને મને ખૂબ જ અભિવ્યક્ત રીતે જોશે).

તેથી, આ નોંધમાં હું તમને કહીશ કે હું કેવી રીતે શીખ્યો:

1. જેનકિન્સમાં નોકરીમાંથી અથવા અન્ય નોકરીઓમાંથી ગતિશીલ રીતે અપડેટ કરો;
2. જેનકિન્સ એજન્ટ ઇન્સ્ટોલ કરેલા નોડમાંથી ક્લાઉડ કન્સોલ (ક્લાઉડ શેલ) સાથે કનેક્ટ કરો;
3. Google Kubernetes Engine પર વર્કલોડનો ઉપયોગ કરો.

હકીકતમાં, હું, અલબત્ત, કંઈક અંશે કપટી છું. એવું માનવામાં આવે છે કે તમારી પાસે Google ક્લાઉડમાં ઇન્ફ્રાસ્ટ્રક્ચરનો ઓછામાં ઓછો ભાગ છે, અને તેથી, તમે તેના વપરાશકર્તા છો અને, અલબત્ત, તમારી પાસે GCP એકાઉન્ટ છે. પરંતુ તે આ નોટ વિશે નથી.

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

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

જેનકિન્સમાં જોબ સેટિંગ્સને ગતિશીલ રીતે અપડેટ કરી રહ્યું છે

હું તમારા પ્રશ્નની આગાહી કરું છું: ગતિશીલ જોબ અપડેટનો તેની સાથે શું સંબંધ છે? સ્ટ્રિંગ પેરામીટરનું મૂલ્ય જાતે દાખલ કરો અને તમે જાઓ છો!

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

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

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

ત્યાં ઘણા બધા વિકલ્પો નથી. બે વસ્તુઓ તરત જ ધ્યાનમાં આવી:

• રીમોટ એક્સેસ API નો ઉપયોગ કરો જે જેનકિન્સ તેના વપરાશકર્તાઓને ઓફર કરે છે;
• રિમોટ રિપોઝીટરી ફોલ્ડરની સામગ્રીની વિનંતી કરો (અમારા કિસ્સામાં આ જેફ્રોગ આર્ટિફેક્ટરી છે, જે મહત્વપૂર્ણ નથી).

જેનકિન્સ રિમોટ એક્સેસ API

સ્થાપિત ઉત્કૃષ્ટ પરંપરા અનુસાર, હું લાંબા ખુલાસા ટાળવાનું પસંદ કરીશ.
હું મારી જાતને ફક્ત પ્રથમ ફકરાના એક ભાગના મફત અનુવાદની મંજૂરી આપીશ API દસ્તાવેજીકરણનું પ્રથમ પૃષ્ઠ:

જેનકિન્સ તેની કાર્યક્ષમતા માટે દૂરસ્થ મશીન-વાંચી શકાય તેવી ઍક્સેસ માટે API પ્રદાન કરે છે. <…> રિમોટ એક્સેસ REST જેવી શૈલીમાં આપવામાં આવે છે. આનો અર્થ એ છે કે બધી સુવિધાઓ માટે કોઈ એકલ પ્રવેશ બિંદુ નથી, પરંતુ તેના બદલે "જેમ કે URL.../api/", ક્યાં"..."નો અર્થ એ છે કે જે ઑબ્જેક્ટ પર API ક્ષમતાઓ લાગુ કરવામાં આવે છે.

બીજા શબ્દોમાં કહીએ તો, જો આપણે હાલમાં જે જમાવટ કાર્ય વિશે વાત કરી રહ્યા છીએ તે ઉપલબ્ધ છે http://jenkins.mybuild.er/view/AweSomeApp/job/AweSomeApp_build, પછી આ કાર્ય માટે API વ્હિસલ્સ પર ઉપલબ્ધ છે http://jenkins.mybuild.er/view/AweSomeApp/job/AweSomeApp_build/api/

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

ચાલો ફક્ત તમામ જોબ રનની સૂચિ મેળવવાનો પ્રયાસ કરીએ. અમને ફક્ત એસેમ્બલીના નામમાં રસ છે (ડિસ્પ્લે નામ) અને તેનું પરિણામ (પરિણામ):

http://jenkins.mybuild.er/view/AweSomeApp/job/AweSomeApp_build/api/xml?tree=allBuilds[displayName,result]

શું તે કામ કરે છે?

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

http://jenkins.mybuild.er/view/AweSomeApp/job/AweSomeApp_build/api/xml?tree=allBuilds[displayName,result]&exclude=freeStyleProject/allBuild[result!='SUCCESS']

સફળની યાદીનો સ્ક્રીનશોટ

બસ, માત્ર આનંદ માટે, ચાલો ખાતરી કરીએ કે ફિલ્ટર આપણને છેતરતું નથી (ફિલ્ટર્સ ક્યારેય જૂઠું બોલતા નથી!) અને "અસફળ" લોકોની સૂચિ પ્રદર્શિત કરીએ:

http://jenkins.mybuild.er/view/AweSomeApp/job/AweSomeApp_build/api/xml?tree=allBuilds[displayName,result]&exclude=freeStyleProject/allBuild[result='SUCCESS']

બિન-સફળ લોકોની સૂચિનો સ્ક્રીનશોટ

દૂરસ્થ સર્વર પર ફોલ્ડરમાંથી સંસ્કરણોની સૂચિ

સંસ્કરણોની સૂચિ મેળવવાની બીજી રીત છે. મને તે જેનકિન્સ API ને ઍક્સેસ કરવા કરતાં પણ વધુ ગમે છે. ઠીક છે, કારણ કે જો એપ્લિકેશન સફળતાપૂર્વક બનાવવામાં આવી હતી, તો તેનો અર્થ એ છે કે તે પેકેજ્ડ અને યોગ્ય ફોલ્ડરમાં રિપોઝીટરીમાં મૂકવામાં આવ્યું હતું. જેમ કે, રીપોઝીટરી એ એપ્લિકેશનના વર્કિંગ વર્ઝનનો ડિફોલ્ટ સ્ટોરેજ છે. ગમે છે. સારું, ચાલો તેને પૂછીએ કે સ્ટોરેજમાં કયા સંસ્કરણો છે. અમે રિમોટ ફોલ્ડરને કર્લ, grep અને awk કરીશું. જો કોઈને વનલાઈનરમાં રસ હોય, તો તે સ્પોઈલર હેઠળ છે.

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

curl -H "X-JFrog-Art-Api:VeryLongAPIKey" -s http://arts.myre.po/artifactory/awesomeapp/ | sed 's/a href=//' | grep "$(date +%b)-$(date +%Y)|$(date +%b --date='-1 month')-$(date +%Y)" | awk '{print $1}' | grep -oP '>K[^/]+' )

જેનકિન્સમાં જોબ્સ અને જોબ કન્ફિગરેશન ફાઇલ સેટ કરવી

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

એસેમ્બલી કાર્ય સેટિંગ્સ ખોલો અને ખૂબ જ તળિયે સ્ક્રોલ કરો. બટનો પર ક્લિક કરો: બિલ્ડ પગલું ઉમેરો -> શરતી પગલું (સિંગલ). સ્ટેપ સેટિંગ્સમાં, શરત પસંદ કરો વર્તમાન બિલ્ડ સ્થિતિ, મૂલ્ય સેટ કરો સફળતા, જો સફળ થાય તો કરવા માટેની ક્રિયા શેલ આદેશ ચલાવો.

અને હવે મજા ભાગ. જેનકિન્સ જોબ કન્ફિગરેશનને ફાઇલોમાં સ્ટોર કરે છે. XML ફોર્મેટમાં. રસ્તામાં http://путь-до-задания/config.xml તદનુસાર, તમે રૂપરેખાંકન ફાઇલને ડાઉનલોડ કરી શકો છો, તેને આવશ્યકતા મુજબ સંપાદિત કરી શકો છો અને તેને જ્યાંથી મળી ત્યાં તેને પાછું મૂકી શકો છો.

યાદ રાખો, અમે ઉપર સંમત થયા છીએ કે અમે સંસ્કરણોની સૂચિ માટે એક પરિમાણ બનાવીશું BUILD_VERSION?

ચાલો રૂપરેખાંકન ફાઈલ ડાઉનલોડ કરીએ અને તેની અંદર એક નજર કરીએ. ફક્ત ખાતરી કરવા માટે કે પરિમાણ સ્થાને છે અને ઇચ્છિત પ્રકારનું છે.

સ્પોઇલર હેઠળ સ્ક્રીનશૉટ.

તમારું config.xml ફ્રેગમેન્ટ સમાન દેખાવું જોઈએ. સિવાય કે પસંદગીના તત્વની સામગ્રી હજી ખૂટે છે

શું તમને ખાતરી છે? બસ, ચાલો એક સ્ક્રિપ્ટ લખીએ જે બિલ્ડ સફળ થાય તો અમલમાં મુકવામાં આવશે.
સ્ક્રિપ્ટ સંસ્કરણોની સૂચિ મેળવશે, રૂપરેખાંકન ફાઇલ ડાઉનલોડ કરશે, અમને જરૂર હોય ત્યાં સંસ્કરણોની સૂચિ લખશે અને પછી તેને પાછું મૂકશે. હા. તે સાચું છે. XML માં સંસ્કરણોની સૂચિ લખો જ્યાં પહેલાથી જ સંસ્કરણોની સૂચિ છે (સ્ક્રીપ્ટના પ્રથમ લોંચ પછી ભવિષ્યમાં હશે). હું જાણું છું કે વિશ્વમાં હજી પણ નિયમિત અભિવ્યક્તિના ઉગ્ર ચાહકો છે. હું તેમનો નથી. કૃપા કરીને ઇન્સ્ટોલ કરો xmlstarler મશીન પર જ્યાં રૂપરેખા સંપાદિત કરવામાં આવશે. મને લાગે છે કે sed નો ઉપયોગ કરીને XML ને સંપાદિત કરવાનું ટાળવા માટે ચૂકવણી કરવા માટે આ એટલી મોટી કિંમત નથી.

સ્પોઇલર હેઠળ, હું કોડ રજૂ કરું છું જે ઉપરોક્ત ક્રમને તેની સંપૂર્ણતામાં કરે છે.

રિમોટ સર્વર પરના ફોલ્ડરમાંથી રૂપરેખા પર આવૃત્તિઓની યાદી લખો

#!/bin/bash
############## Скачиваем конфиг
curl -X GET -u username:apiKey http://jenkins.mybuild.er/view/AweSomeApp/job/AweSomeApp_k8s/config.xml -o appConfig.xml

############## Удаляем и заново создаем xml-элемент для списка версий
xmlstarlet ed --inplace -d '/project/properties/hudson.model.ParametersDefinitionProperty/parameterDefinitions/hudson.model.ChoiceParameterDefinition[name="BUILD_VERSION"]/choices[@class="java.util.Arrays$ArrayList"]/a[@class="string-array"]' appConfig.xml

xmlstarlet ed --inplace --subnode '/project/properties/hudson.model.ParametersDefinitionProperty/parameterDefinitions/hudson.model.ChoiceParameterDefinition[name="BUILD_VERSION"]/choices[@class="java.util.Arrays$ArrayList"]' --type elem -n a appConfig.xml

xmlstarlet ed --inplace --insert '/project/properties/hudson.model.ParametersDefinitionProperty/parameterDefinitions/hudson.model.ChoiceParameterDefinition[name="BUILD_VERSION"]/choices[@class="java.util.Arrays$ArrayList"]/a' --type attr -n class -v string-array appConfig.xml

############## Читаем в массив список версий из репозитория
readarray -t vers < <( curl -H "X-JFrog-Art-Api:Api:VeryLongAPIKey" -s http://arts.myre.po/artifactory/awesomeapp/ | sed 's/a href=//' | grep "$(date +%b)-$(date +%Y)|$(date +%b --date='-1 month')-$(date +%Y)" | awk '{print $1}' | grep -oP '>K[^/]+' )

############## Пишем массив элемент за элементом в конфиг
printf '%sn' "${vers[@]}" | sort -r | 
                while IFS= read -r line
                do
                    xmlstarlet ed --inplace --subnode '/project/properties/hudson.model.ParametersDefinitionProperty/parameterDefinitions/hudson.model.ChoiceParameterDefinition[name="BUILD_VERSION"]/choices[@class="java.util.Arrays$ArrayList"]/a[@class="string-array"]' --type elem -n string -v "$line" appConfig.xml
                done

############## Кладем конфиг взад
curl -X POST -u username:apiKey http://jenkins.mybuild.er/view/AweSomeApp/job/AweSomeApp_k8s/config.xml --data-binary @appConfig.xml

############## Приводим рабочее место в порядок
rm -f appConfig.xml

જો તમે જેનકિન્સ પાસેથી સંસ્કરણો મેળવવાનો વિકલ્પ પસંદ કરો છો અને તમે મારા જેવા આળસુ છો, તો પછી સ્પોઇલર હેઠળ સમાન કોડ છે, પરંતુ જેનકિન્સ તરફથી સૂચિ:

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

#!/bin/bash
############## Скачиваем конфиг
curl -X GET -u username:apiKey http://jenkins.mybuild.er/view/AweSomeApp/job/AweSomeApp_k8s/config.xml -o appConfig.xml

############## Удаляем и заново создаем xml-элемент для списка версий
xmlstarlet ed --inplace -d '/project/properties/hudson.model.ParametersDefinitionProperty/parameterDefinitions/hudson.model.ChoiceParameterDefinition[name="BUILD_VERSION"]/choices[@class="java.util.Arrays$ArrayList"]/a[@class="string-array"]' appConfig.xml

xmlstarlet ed --inplace --subnode '/project/properties/hudson.model.ParametersDefinitionProperty/parameterDefinitions/hudson.model.ChoiceParameterDefinition[name="BUILD_VERSION"]/choices[@class="java.util.Arrays$ArrayList"]' --type elem -n a appConfig.xml

xmlstarlet ed --inplace --insert '/project/properties/hudson.model.ParametersDefinitionProperty/parameterDefinitions/hudson.model.ChoiceParameterDefinition[name="BUILD_VERSION"]/choices[@class="java.util.Arrays$ArrayList"]/a' --type attr -n class -v string-array appConfig.xml

############## Пишем в файл список версий из Jenkins
curl -g -X GET -u username:apiKey 'http://jenkins.mybuild.er/view/AweSomeApp/job/AweSomeApp_build/api/xml?tree=allBuilds[displayName,result]&exclude=freeStyleProject/allBuild[result!=%22SUCCESS%22]&pretty=true' -o builds.xml

############## Читаем в массив список версий из XML
readarray vers < <(xmlstarlet sel -t -v "freeStyleProject/allBuild/displayName" builds.xml | awk -F":" '{print $2}')

############## Пишем массив элемент за элементом в конфиг
printf '%sn' "${vers[@]}" | sort -r | 
                while IFS= read -r line
                do
                    xmlstarlet ed --inplace --subnode '/project/properties/hudson.model.ParametersDefinitionProperty/parameterDefinitions/hudson.model.ChoiceParameterDefinition[name="BUILD_VERSION"]/choices[@class="java.util.Arrays$ArrayList"]/a[@class="string-array"]' --type elem -n string -v "$line" appConfig.xml
                done

############## Кладем конфиг взад
curl -X POST -u username:apiKey http://jenkins.mybuild.er/view/AweSomeApp/job/AweSomeApp_k8s/config.xml --data-binary @appConfig.xml

############## Приводим рабочее место в порядок
rm -f appConfig.xml

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

આવૃત્તિઓની યોગ્ય રીતે પૂર્ણ કરેલી સૂચિ

જો બધું કામ કરે છે, તો પછી સ્ક્રિપ્ટને કોપી-પેસ્ટ કરો શેલ આદેશ ચલાવો અને ફેરફારો સાચવો.

ક્લાઉડ શેલ સાથે કનેક્ટ થઈ રહ્યું છે

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

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

ક્લાઉડ કન્સોલથી કનેક્ટ થવા માટે, તમારે બે વસ્તુઓની જરૂર છે: gCloud અને ઍક્સેસ અધિકારો Google Cloud API VM ઉદાહરણ માટે કે જેમાંથી આ જ જોડાણ કરવામાં આવશે.

જેઓ ગૂગલ ક્લાઉડથી બિલકુલ કનેક્ટ ન થવાનું વિચારે છે
Google તેની સેવાઓમાં ઇન્ટરેક્ટિવ અધિકૃતતાને અક્ષમ કરવાની શક્યતાને મંજૂરી આપે છે. આ તમને કોફી મશીનમાંથી પણ કન્સોલ સાથે જોડાવા માટે પરવાનગી આપશે, જો તે *nix ચાલી રહ્યું હોય અને તેમાં કન્સોલ હોય.

જો મને આ નોંધના માળખામાં આ મુદ્દાને વધુ વિગતવાર આવરી લેવાની જરૂર હોય, તો ટિપ્પણીઓમાં લખો. જો અમને પૂરતા મત મળશે, તો હું આ વિષય પર અપડેટ લખીશ.

અધિકારો આપવાનો સૌથી સહેલો રસ્તો વેબ ઈન્ટરફેસ દ્વારા છે.

1. VM ઉદાહરણને રોકો કે જેમાંથી તમે પછીથી ક્લાઉડ કન્સોલ સાથે કનેક્ટ થશો.
2. દાખલાની વિગતો ખોલો અને ક્લિક કરો સુધારો.
3. પૃષ્ઠના ખૂબ જ તળિયે, ઇન્સ્ટન્સ એક્સેસ સ્કોપ પસંદ કરો તમામ ક્લાઉડ API ની સંપૂર્ણ ઍક્સેસ.

   સ્ક્રીનશોટ
   

4. તમારા ફેરફારો સાચવો અને દાખલો લોંચ કરો.

એકવાર VM લોડ કરવાનું સમાપ્ત કરી લે, પછી તેને SSH દ્વારા કનેક્ટ કરો અને ખાતરી કરો કે કનેક્શન ભૂલ વિના થાય છે. આદેશનો ઉપયોગ કરો:

gcloud alpha cloud-shell ssh

સફળ કનેક્શન કંઈક આના જેવું લાગે છે

GKE માં જમાવટ કરો

અમે IaC (કોડ તરીકે ઇન્ફ્રાસ્ટ્રક્ચર) પર સંપૂર્ણપણે સ્વિચ કરવા માટે દરેક સંભવિત રીતે પ્રયાસ કરી રહ્યા હોવાથી, અમારી ડોકર ફાઇલો Git માં સંગ્રહિત છે. આ એક તરફ છે. અને kubernetes માં જમાવટ yaml ફાઇલ દ્વારા વર્ણવવામાં આવે છે, જેનો ઉપયોગ ફક્ત આ કાર્ય દ્વારા થાય છે, જે પોતે પણ કોડ જેવું છે. આ બીજી બાજુથી છે. સામાન્ય રીતે, મારો મતલબ, યોજના આ છે:

1. આપણે ચલોની કિંમતો લઈએ છીએ BUILD_VERSION અને, વૈકલ્પિક રીતે, ચલોની કિંમતો જેમાંથી પસાર થશે ENV.
2. ગિટમાંથી ડોકરફાઇલ ડાઉનલોડ કરો.
3. જમાવટ માટે yaml જનરેટ કરો.
4. અમે આ બંને ફાઇલોને scp દ્વારા ક્લાઉડ કન્સોલ પર અપલોડ કરીએ છીએ.
5. અમે ત્યાં એક કન્ટેનર બનાવીએ છીએ અને તેને કન્ટેનર રજિસ્ટ્રીમાં દબાણ કરીએ છીએ
6. અમે ક્યુબર પર લોડ ડિપ્લોયમેન્ટ ફાઇલ લાગુ કરીએ છીએ.

ચાલો વધુ ચોક્કસ બનીએ. એકવાર અમે વિશે વાત કરવાનું શરૂ કર્યું ENV, પછી ધારો કે આપણે બે પરિમાણોના મૂલ્યો પસાર કરવાની જરૂર છે: PARAM1 и PARAM2. અમે જમાવટ માટે તેમનું કાર્ય ઉમેરીએ છીએ, પ્રકાર - શબ્દમાળા પરિમાણ.

સ્ક્રીનશોટ

અમે સરળ રીડાયરેક્શન સાથે yaml જનરેટ કરીશું ઇકો ફાઈલ કરવા માટે. એવું માનવામાં આવે છે કે, અલબત્ત, તમારી પાસે તમારી ડોકરફાઈલમાં છે PARAM1 и PARAM2કે લોડ નામ હશે awesomeapp, અને ઉલ્લેખિત સંસ્કરણની એપ્લિકેશન સાથે એસેમ્બલ કન્ટેનર આવેલું છે કન્ટેનર રજિસ્ટ્રી રસ્તામા gcr.io/awesomeapp/awesomeapp-$BUILD_VERSIONજ્યાં $BUILD_VERSION હમણાં જ ડ્રોપ-ડાઉન સૂચિમાંથી પસંદ કરવામાં આવ્યું હતું.

ટીમ યાદી

touch deploy.yaml
echo "apiVersion: apps/v1" >> deploy.yaml
echo "kind: Deployment" >> deploy.yaml
echo "metadata:" >> deploy.yaml
echo "  name: awesomeapp" >> deploy.yaml
echo "spec:" >> deploy.yaml
echo "  replicas: 1" >> deploy.yaml
echo "  selector:" >> deploy.yaml
echo "    matchLabels:" >> deploy.yaml
echo "      run: awesomeapp" >> deploy.yaml
echo "  template:" >> deploy.yaml
echo "    metadata:" >> deploy.yaml
echo "      labels:" >> deploy.yaml
echo "        run: awesomeapp" >> deploy.yaml
echo "    spec:" >> deploy.yaml
echo "      containers:" >> deploy.yaml
echo "      - name: awesomeapp" >> deploy.yaml
echo "        image: gcr.io/awesomeapp/awesomeapp-$BUILD_VERSION:latest" >> deploy.yaml
echo "        env:" >> deploy.yaml
echo "        - name: PARAM1" >> deploy.yaml
echo "          value: $PARAM1" >> deploy.yaml
echo "        - name: PARAM2" >> deploy.yaml
echo "          value: $PARAM2" >> deploy.yaml

ઉપયોગ કરીને કનેક્ટ કર્યા પછી જેનકિન્સ એજન્ટ gcloud alpha cloud-shell ssh ઇન્ટરેક્ટિવ મોડ ઉપલબ્ધ નથી, તેથી અમે પેરામીટરનો ઉપયોગ કરીને ક્લાઉડ કન્સોલને આદેશો મોકલીએ છીએ --આદેશ.

અમે જૂની ડોકરફાઇલમાંથી ક્લાઉડ કન્સોલમાં હોમ ફોલ્ડરને સાફ કરીએ છીએ:

gcloud alpha cloud-shell ssh --command="rm -f Dockerfile"

scp નો ઉપયોગ કરીને ક્લાઉડ કન્સોલના હોમ ફોલ્ડરમાં તાજી ડાઉનલોડ કરેલી ડોકરફાઈલ મૂકો:

gcloud alpha cloud-shell scp localhost:./Dockerfile cloudshell:~

અમે કન્ટેનરને કન્ટેનર રજિસ્ટ્રીમાં એકત્રિત કરીએ છીએ, ટેગ કરીએ છીએ અને દબાણ કરીએ છીએ:

gcloud alpha cloud-shell ssh --command="docker build -t awesomeapp-$BUILD_VERSION ./ --build-arg BUILD_VERSION=$BUILD_VERSION --no-cache"
gcloud alpha cloud-shell ssh --command="docker tag awesomeapp-$BUILD_VERSION gcr.io/awesomeapp/awesomeapp-$BUILD_VERSION"
gcloud alpha cloud-shell ssh --command="docker push gcr.io/awesomeapp/awesomeapp-$BUILD_VERSION"

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

gcloud alpha cloud-shell ssh --command="rm -f deploy.yaml"
gcloud alpha cloud-shell scp localhost:./deploy.yaml cloudshell:~
gcloud alpha cloud-shell ssh --command="gcloud container clusters get-credentials awsm-cluster --zone us-central1-c --project awesome-project && 
kubectl apply -f deploy.yaml"

અમે કાર્ય ચલાવીએ છીએ, કન્સોલ આઉટપુટ ખોલીએ છીએ અને કન્ટેનરની સફળ એસેમ્બલી જોવાની આશા રાખીએ છીએ.

સ્ક્રીનશોટ

અને પછી એસેમ્બલ કન્ટેનરની સફળ જમાવટ

સ્ક્રીનશોટ

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

તારણોને બદલે

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

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

સોર્સ: www.habr.com