Nagsimula ang lahat nang hilingin sa amin ng pinuno ng team ng isa sa aming mga development team na subukan ang kanilang bagong aplikasyon, na na-container noong nakaraang araw. Pinost ko ito. Pagkaraan ng humigit-kumulang 20 minuto, isang kahilingan ang natanggap na i-update ang aplikasyon, dahil isang napakakailangang bagay ang naidagdag doon. nag renew ako. Pagkatapos ng isa pang ilang oras... well, maaari mong hulaan kung ano ang nagsimulang mangyari sa susunod...
Aaminin ko, medyo tamad ako (hindi ba inamin ko ito kanina? Hindi?), at dahil sa katotohanan na ang mga lead team ay may access sa Jenkins, kung saan mayroon kaming lahat ng CI/CD, naisip ko: hayaan siyang mag-deploy bilang sa dami ng gusto niya! Naalala ko ang isang biro: bigyan ang isang tao ng isda at kakain siya sa isang araw; tawagin ang isang tao na Fed at siya ay magiging Fed sa buong buhay niya. At nagpunta maglaro ng mga trick sa trabaho, na makakapag-deploy ng container na naglalaman ng application ng anumang matagumpay na binuong bersyon sa Kuber at maglipat ng anumang value dito ENV (Ang aking lolo, isang philologist, isang guro sa Ingles sa nakaraan, ngayon ay iikot ang kanyang daliri sa kanyang templo at tumingin sa akin nang napakapahayag pagkatapos basahin ang pangungusap na ito).
Kaya, sa tala na ito sasabihin ko sa iyo kung paano ko natutunan:
- Dynamic na i-update ang mga trabaho sa Jenkins mula sa trabaho mismo o mula sa iba pang mga trabaho;
- Kumonekta sa cloud console (Cloud shell) mula sa isang node na may naka-install na Jenkins agent;
- I-deploy ang workload sa Google Kubernetes Engine.
Sa katunayan, ako, siyempre, ay medyo hindi matapat. Ipinapalagay na mayroon kang hindi bababa sa bahagi ng imprastraktura sa Google cloud, at, samakatuwid, ikaw ang gumagamit nito at, siyempre, mayroon kang GCP account. Ngunit hindi iyon ang tungkol sa tala na ito.
Ito ang aking susunod na cheat sheet. Gusto ko lang magsulat ng mga ganoong tala sa isang kaso: Nahaharap ako sa isang problema, sa una ay hindi ko alam kung paano ito lutasin, ang solusyon ay hindi na-google na handa, kaya't nag-google ako sa mga bahagi at kalaunan ay nalutas ang problema. At upang sa hinaharap, kapag nakalimutan ko kung paano ko ito ginawa, hindi ko na kailangang i-google muli ang lahat nang paisa-isa at i-compile ito nang sama-sama, isinulat ko ang aking sarili ng gayong mga cheat sheet.
Disclaimer: 1. Ang tala ay isinulat "para sa aking sarili", para sa papel pinakamahusay na kasanayan hindi nalalapat. Ikinalulugod kong basahin ang mga opsyon na "mas mabuti na gawin ito sa ganitong paraan" sa mga komento.
2. Kung ang inilapat na bahagi ng tala ay itinuturing na asin, kung gayon, tulad ng lahat ng aking mga nakaraang tala, ang isang ito ay isang mahinang solusyon sa asin.
Dynamic na pag-update ng mga setting ng trabaho sa Jenkins
Nakikita ko ang iyong tanong: ano ang kinalaman dito ng dynamic na pag-update ng trabaho? Ipasok ang halaga ng string parameter nang manu-mano at umalis ka na!
Sagot ko: Tinatamad talaga ako, ayoko kapag nagrereklamo sila: Misha, bumagsak ang deployment, wala na ang lahat! Nagsisimula kang maghanap, at mayroong isang typo sa halaga ng ilang parameter ng paglulunsad ng gawain. Samakatuwid, mas gusto kong gawin ang lahat nang mahusay hangga't maaari. Kung posible na pigilan ang gumagamit mula sa direktang pagpasok ng data sa pamamagitan ng pagbibigay sa halip ng isang listahan ng mga halaga na mapagpipilian, pagkatapos ay ayusin ko ang pagpili.
Ang plano ay ito: lumikha kami ng trabaho sa Jenkins, kung saan, bago ilunsad, maaari kaming pumili ng bersyon mula sa listahan, tukuyin ang mga halaga para sa mga parameter na ipinasa sa lalagyan sa pamamagitan ng ENV, pagkatapos ay kinokolekta nito ang container at itulak ito sa Container Registry. Pagkatapos mula doon ang lalagyan ay inilunsad sa cuber bilang workload kasama ang mga parameter na tinukoy sa trabaho.
Hindi namin isasaalang-alang ang proseso ng paglikha at pag-set up ng trabaho sa Jenkins, ito ay wala sa paksa. Ipagpalagay natin na handa na ang gawain. Upang ipatupad ang isang na-update na listahan na may mga bersyon, kailangan namin ng dalawang bagay: isang umiiral na listahan ng pinagmulan na may mga priori valid na numero ng bersyon at isang variable na tulad ng Parameter ng pagpili sa gawain. Sa aming halimbawa, hayaang pangalanan ang variable BUILD_VERSION, hindi namin ito tatalakayin nang detalyado. Ngunit tingnan natin ang listahan ng pinagmulan.
Walang ganoong karaming mga pagpipilian. Dalawang bagay ang agad na naisip:
- Gamitin ang Remote access API na inaalok ni Jenkins sa mga user nito;
- Hilingin ang mga nilalaman ng remote repository folder (sa aming kaso ito ay JFrog Artifactory, na hindi mahalaga).
Jenkins Remote access API
Ayon sa itinatag na mahusay na tradisyon, mas gugustuhin kong iwasan ang mahahabang paliwanag.
Papayagan ko ang aking sarili ng isang libreng pagsasalin lamang ng isang piraso ng unang talata :
Nagbibigay ang Jenkins ng API para sa malayuang nababasa ng makina na access sa functionality nito. <...> Ang malayuang pag-access ay inaalok sa istilong tulad ng REST. Nangangahulugan ito na walang iisang entry point sa lahat ng feature, ngunit sa halip ay isang URL tulad ng ".../api/", Saan"..." ay nangangahulugang ang bagay kung saan inilalapat ang mga kakayahan ng API.
Sa madaling salita, kung ang deployment task na kasalukuyang pinag-uusapan natin ay available sa http://jenkins.mybuild.er/view/AweSomeApp/job/AweSomeApp_build, pagkatapos ay available ang API whistles para sa gawaing ito sa http://jenkins.mybuild.er/view/AweSomeApp/job/AweSomeApp_build/api/
Susunod, mayroon kaming pagpipilian sa kung anong anyo upang matanggap ang output. Tumutok tayo sa XML, dahil pinapayagan lang ng API ang pag-filter sa kasong ito.
Subukan lang nating kumuha ng listahan ng lahat ng mga pinapatakbong trabaho. Interesado lang kami sa pangalan ng assembly (displayName) at ang resulta nito (resulta):
http://jenkins.mybuild.er/view/AweSomeApp/job/AweSomeApp_build/api/xml?tree=allBuilds[displayName,result]Ito ay naka-out?
Ngayon, i-filter lang natin ang mga run na nagtatapos sa resulta TAGUMPAY. Gamitin natin ang argumento &ibukod at bilang isang parameter ay ipapasa namin ito sa landas sa isang halaga na hindi katumbas ng TAGUMPAY. Oo Oo. Ang dobleng negatibo ay isang pahayag. Ibinubukod namin ang lahat ng hindi interesado sa amin:
http://jenkins.mybuild.er/view/AweSomeApp/job/AweSomeApp_build/api/xml?tree=allBuilds[displayName,result]&exclude=freeStyleProject/allBuild[result!='SUCCESS'] Screenshot ng listahan ng matagumpay
Well, para lang masaya, siguraduhin nating hindi tayo nilinlang ng filter (hindi nagsisinungaling ang mga filter!) at magpakita ng listahan ng mga "hindi matagumpay":
http://jenkins.mybuild.er/view/AweSomeApp/job/AweSomeApp_build/api/xml?tree=allBuilds[displayName,result]&exclude=freeStyleProject/allBuild[result='SUCCESS'] Screenshot ng listahan ng mga hindi matagumpay
Listahan ng mga bersyon mula sa isang folder sa isang malayuang server
May pangalawang paraan para makakuha ng listahan ng mga bersyon. Mas gusto ko ito kaysa sa pag-access sa Jenkins API. Well, dahil kung ang application ay matagumpay na binuo, nangangahulugan ito na ito ay nakabalot at inilagay sa repository sa naaangkop na folder. Tulad ng, ang isang imbakan ay ang default na imbakan ng mga gumaganang bersyon ng mga application. Gaya ng. Well, tanungin natin siya kung anong mga bersyon ang nasa storage. Kami ay kulot, grep at awk ang remote folder. Kung sinuman ang interesado sa oneliner, kung gayon ito ay nasa ilalim ng spoiler.
Isang linyang utos
Pakitandaan ang dalawang bagay: Ipinapasa ko ang mga detalye ng koneksyon sa header at hindi ko kailangan ang lahat ng bersyon mula sa folder, at pipiliin ko lang ang mga ginawa sa loob ng isang buwan. I-edit ang command upang umangkop sa iyong mga katotohanan at pangangailangan:
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[^/]+' )Pagse-set up ng mga trabaho at job configuration file sa Jenkins
Nalaman namin ang pinagmulan ng listahan ng mga bersyon. Isama natin ngayon ang resultang listahan sa gawain. Para sa akin, ang malinaw na solusyon ay ang magdagdag ng isang hakbang sa application build task. Ang hakbang na isasagawa kung ang resulta ay "tagumpay".
Buksan ang mga setting ng gawain sa pagpupulong at mag-scroll sa pinakaibaba. Mag-click sa mga pindutan: Magdagdag ng hakbang sa pagbuo -> Kondisyon na hakbang (iisa). Sa mga setting ng hakbang, piliin ang kundisyon Kasalukuyang katayuan ng build, itakda ang halaga TAGUMPAY, ang aksyon na isasagawa kung matagumpay Patakbuhin ang utos ng shell.
At ngayon ang masayang bahagi. Iniimbak ni Jenkins ang mga configuration ng trabaho sa mga file. Sa XML na format. Sa daan http://ΠΏΡΡΡ-Π΄ΠΎ-Π·Π°Π΄Π°Π½ΠΈΡ/config.xml Alinsunod dito, maaari mong i-download ang configuration file, i-edit ito kung kinakailangan at ibalik ito kung saan mo ito nakuha.
Tandaan, napagkasunduan namin sa itaas na gagawa kami ng parameter para sa listahan ng mga bersyon BUILD_VERSION?
I-download natin ang configuration file at tingnan natin ang loob nito. Para lang matiyak na ang parameter ay nasa lugar at sa nais na uri.
Screenshot sa ilalim ng spoiler.
Dapat pareho ang hitsura ng iyong config.xml fragment. Maliban na ang mga nilalaman ng elemento ng mga pagpipilian ay wala pa
Sigurado ka ba? Iyon lang, magsulat tayo ng isang script na isasagawa kung matagumpay ang pagbuo.
Ang script ay makakatanggap ng isang listahan ng mga bersyon, i-download ang configuration file, isulat ang listahan ng mga bersyon dito sa lugar na kailangan namin, at pagkatapos ay ibalik ito. Oo. Tama iyan. Sumulat ng isang listahan ng mga bersyon sa XML sa lugar kung saan mayroon nang listahan ng mga bersyon (ay sa hinaharap, pagkatapos ng unang paglulunsad ng script). Alam kong may mga mabangis na tagahanga ng mga regular na expression sa mundo. Hindi ako sa kanila. Mangyaring i-install sa makina kung saan ie-edit ang config. Para sa akin, hindi ito ganoon kalaki na halagang babayaran para maiwasan ang pag-edit ng XML gamit ang sed.
Sa ilalim ng spoiler, ipinakita ko ang code na gumaganap sa pagkakasunud-sunod sa itaas sa kabuuan nito.
Sumulat ng isang listahan ng mga bersyon mula sa isang folder sa remote server hanggang sa config
#!/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.xmlKung mas gusto mo ang opsyon na makakuha ng mga bersyon mula kay Jenkins at tamad ka tulad ko, sa ilalim ng spoiler ay ang parehong code, ngunit isang listahan mula kay Jenkins:
Sumulat ng isang listahan ng mga bersyon mula kay Jenkins hanggang sa config
Isaisip lamang ito: ang aking pangalan ng assembly ay binubuo ng isang sequence number at isang numero ng bersyon, na pinaghihiwalay ng isang colon. Alinsunod dito, pinuputol ng awk ang hindi kinakailangang bahagi. Para sa iyong sarili, baguhin ang linyang ito upang umangkop sa iyong mga pangangailangan.
#!/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.xmlSa teorya, kung sinubukan mo ang code na nakasulat batay sa mga halimbawa sa itaas, pagkatapos ay sa deployment task dapat mayroon ka nang drop-down list na may mga bersyon. Parang nasa screenshot sa ilalim ng spoiler.
Tamang nakumpletong listahan ng mga bersyon
Kung gumana ang lahat, pagkatapos ay i-copy-paste ang script sa Patakbuhin ang utos ng shell at i-save ang mga pagbabago.
Kumokonekta sa Cloud shell
Mayroon kaming mga kolektor sa mga lalagyan. Ginagamit namin ang Ansible bilang aming tool sa paghahatid ng application at configuration manager. Alinsunod dito, pagdating sa pagbuo ng mga container, tatlong opsyon ang naiisip: i-install ang Docker sa Docker, i-install ang Docker sa isang machine na tumatakbo sa Ansible, o bumuo ng mga container sa isang cloud console. Sumang-ayon kaming manatiling tahimik tungkol sa mga plugin para kay Jenkins sa artikulong ito. Tandaan?
Nagpasya ako: mabuti, dahil ang mga lalagyan na "wala sa kahon" ay maaaring kolektahin sa cloud console, kung gayon bakit mag-abala? Panatilihin itong malinis, tama? Gusto kong mangolekta ng mga lalagyan ng Jenkins sa cloud console, at pagkatapos ay ilunsad ang mga ito sa cuber mula doon. Bukod dito, ang Google ay may napakayaman na mga channel sa loob ng imprastraktura nito, na magkakaroon ng kapaki-pakinabang na epekto sa bilis ng pag-deploy.
Para kumonekta sa cloud console, kailangan mo ng dalawang bagay: gcloud at mga karapatan sa pag-access sa Google Cloud API para sa halimbawa ng VM kung saan gagawin ang parehong koneksyon.
Para sa mga nagpaplanong kumonekta hindi mula sa Google cloud
Pinapayagan ng Google ang posibilidad na i-disable ang interactive na awtorisasyon sa mga serbisyo nito. Papayagan ka nitong kumonekta sa console kahit na mula sa isang coffee machine, kung ito ay tumatakbo *nix at may console mismo.
Kung may pangangailangan para sa akin na saklawin ang isyung ito nang mas detalyado sa loob ng balangkas ng talang ito, sumulat sa mga komento. Kung makakakuha tayo ng sapat na mga boto, magsusulat ako ng update sa paksang ito.
Ang pinakamadaling paraan upang magbigay ng mga karapatan ay sa pamamagitan ng web interface.
- Itigil ang VM instance kung saan ka kumonekta sa cloud console.
- Buksan ang Mga Detalye ng Instance at i-click baguhin.
- Sa pinakailalim ng page, piliin ang saklaw ng pag-access ng instance Ganap na access sa lahat ng Cloud API.
Screenshot
- I-save ang iyong mga pagbabago at ilunsad ang instance.
Kapag natapos na ang pag-load ng VM, kumonekta dito sa pamamagitan ng SSH at tiyaking nangyayari ang koneksyon nang walang error. Gamitin ang command:
gcloud alpha cloud-shell ssh Ang isang matagumpay na koneksyon ay mukhang ganito
I-deploy sa GKE
Dahil nagsusumikap kami sa lahat ng posibleng paraan upang ganap na lumipat sa IaC (Infrastucture as a Code), ang aming mga docker file ay nakaimbak sa Git. Ito ay sa isang banda. At ang pag-deploy sa kubernetes ay inilarawan ng isang yaml file, na ginagamit lamang ng gawaing ito, na mismo ay katulad din ng code. Ito ay mula sa kabilang panig. Sa pangkalahatan, ang ibig kong sabihin, ang plano ay ito:
- Kinukuha namin ang mga halaga ng mga variable BUILD_VERSION at, opsyonal, ang mga halaga ng mga variable na ipapasa ENV.
- I-download ang dockerfile mula sa Git.
- Bumuo ng yaml para sa pag-deploy.
- Ina-upload namin ang parehong mga file na ito sa pamamagitan ng scp sa cloud console.
- Bumubuo kami ng container doon at itinutulak ito sa registry ng Container
- Inilapat namin ang load deployment file sa cuber.
Maging mas tiyak tayo. Sa sandaling nagsimula kaming mag-usap tungkol sa ENV, pagkatapos ay ipagpalagay na kailangan nating ipasa ang mga halaga ng dalawang mga parameter: PARAM1 ΠΈ PARAM2. Idinagdag namin ang kanilang gawain para sa pag-deploy, uri - Parameter ng String.
Screenshot
Bubuo kami ng yaml gamit ang isang simpleng pag-redirect miss mag-file. Ipinapalagay, siyempre, na mayroon ka sa iyong dockerfile PARAM1 ΠΈ PARAM2na ang magiging pangalan ng pag-load kahanga-hangang app, at ang naka-assemble na lalagyan na may application ng tinukoy na bersyon ay nasa Rehistro ng lalagyan sa daan gcr.io/awesomeapp/awesomeapp-$BUILD_VERSIONSaan $BUILD_VERSION Kakapili lang mula sa drop-down list.
Listahan ng koponan
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.yamlJenkins agent pagkatapos kumonekta gamit gcloud alpha cloud-shell ssh hindi available ang interactive mode, kaya nagpapadala kami ng mga command sa cloud console gamit ang parameter --utos.
Nililinis namin ang home folder sa cloud console mula sa lumang dockerfile:
gcloud alpha cloud-shell ssh --command="rm -f Dockerfile"Ilagay ang bagong-download na dockerfile sa home folder ng cloud console gamit ang scp:
gcloud alpha cloud-shell scp localhost:./Dockerfile cloudshell:~Kinokolekta namin, tina-tag at ini-push ang container sa registry ng Container:
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"
Ginagawa namin ang parehong sa deployment file. Pakitandaan na ang mga utos sa ibaba ay gumagamit ng mga kathang-isip na pangalan ng cluster kung saan nangyayari ang deployment (awsm-cluster) at pangalan ng proyekto (kahanga-hangang-proyekto), kung saan matatagpuan ang cluster.
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"Pinapatakbo namin ang gawain, buksan ang output ng console at umaasa na makita ang matagumpay na pagpupulong ng lalagyan.
Screenshot
At pagkatapos ay ang matagumpay na pag-deploy ng naka-assemble na lalagyan
Screenshot
Sinadya kong hindi pinansin ang setting Pagpasok. Para sa isang simpleng dahilan: kapag na-set up mo na ito workload na may ibinigay na pangalan, mananatili itong gumagana, gaano man karaming deployment na may ganitong pangalan ang gagawin mo. Well, sa pangkalahatan, ito ay medyo lampas sa saklaw ng kasaysayan.
Sa halip na mga konklusyon
Ang lahat ng mga hakbang sa itaas ay malamang na hindi nagawa, ngunit nag-install lamang ng ilang plugin para sa Jenkins, ang kanilang muuulion. Ngunit sa ilang kadahilanan ay hindi ko gusto ang mga plugin. Well, mas tiyak, nagre-resort ako sa kanila dahil sa desperasyon.
At gusto ko lang pumili ng ilang bagong paksa para sa akin. Ang teksto sa itaas ay isa ring paraan upang ibahagi ang mga natuklasan na ginawa ko habang nilulutas ang problemang inilarawan sa pinakasimula. Ibahagi sa mga taong, tulad niya, ay hindi naman isang katakut-takot na lobo sa mga devops. Kung ang aking mga natuklasan ay makakatulong sa kahit sino, ako ay magiging masaya.
Pinagmulan: www.habr.com