Patuloy na Tutorial sa Paghahatid - Pagbuo ng isang Patuloy na Pipeline ng Paghahatid Gamit ang Jenkins

Patuloy na Paghahatid:

Ang tuluy-tuloy na Paghatid ay isang proseso, kung saan ang mga pagbabago sa code ay awtomatikong itinayo, nasubok, at inihanda para sa isang paglabas sa produksyon.Sana nasiyahan ka sa aking Dito, pag-uusapan ko ang tungkol sa mga sumusunod na paksa ::

• Ano ang Patuloy na Paghahatid?
• Mga uri ng Pagsubok ng Software
• Pagkakaiba sa Pagitan ng Patuloy na Pagsasama, Paghahatid, at Pag-deploy
• Ano ang kailangan para sa Patuloy na Paghahatid?
• Hands-on na Paggamit ng Jenkins at Tomcat

Mabilis nating maunawaan kung paano gumagana ang Tuloy-tuloy na Paghahatid.

Ano ang Patuloy na Paghahatid?

Ito ay isang proseso kung saan bumuo ka ng software sa paraang maaari itong mailabas sa paggawa sa anumang oras.Isaalang-alang ang diagram sa ibaba:

Hayaan akong ipaliwanag ang diagram sa itaas:

• Ang mga awtomatikong build script ay makakakita ng mga pagbabago sa Source Code Management (SCM) tulad ng Git.
• Kapag nakita ang pagbabago, ang mapagkukunan ng code ay ipapakalat sa isang nakalaang build server upang matiyak na ang pagbuo ay hindi nabibigo at lahat ng mga klase sa pagsubok at pagsasama ng mga pagsubok ay tumatakbo nang maayos.
• Pagkatapos, ang application ng build ay na-deploy sa mga server ng pagsubok (mga pre-production server) para sa User Acceptance Test (UAT).
• Panghuli, ang application ay manu-manong ipinakalat sa mga server ng produksyon para sa paglabas.

Bago ako magpatuloy, magiging patas lamang na ipinapaliwanag ko sa iyo ang iba't ibang mga uri ng pagsubok.

Mga uri ng Pagsubok ng Software:

Malawakang pagsasalita mayroong dalawang uri ng pagsubok:

• Pagsubok sa Blackbox: Ito ay isang diskarte sa pagsubok na hindi pinapansin ang panloob na mekanismo ng system at nakatuon sa output na nabuo laban sa anumang input at pagpapatupad ng system. Tinatawag din itong pagganap na pagsubok. Karaniwan itong ginagamit para sa pagpapatunay ng software.
• Pagsubok sa Whitebox: ay isang diskarte sa pagsubok na isinasaalang-alang ang panloob na mekanismo ng isang system. Tinatawag din itong struktural na pagsubok at pagsubok sa kahon ng salamin. Karaniwan itong ginagamit para sa pagpapatunay ng software.

Pagsubok sa Whitebox:

Mayroong dalawang uri ng pagsubok, na napapailalim sa kategoryang ito.

• Pagsubok ng Yunit: Ito ay ang pagsubok ng isang indibidwal na yunit o pangkat ng mga kaugnay na yunit. Ito ay madalas na ginagawa ng programmer upang subukan na ang yunit na kanyang ipinatupad ay gumagawa ng inaasahang output laban sa ibinigay na input.
• Pagsubok sa Pagsasama: Ito ay isang uri ng pagsubok kung saan ang isang pangkat ng mga bahagi aypinagsama upang makabuo ng output. Gayundin, ang pakikipag-ugnayan sa pagitan ng software at hardware ay nasubok kung ang mga bahagi ng software at hardware ay may anumang ugnayan. Maaari itong mahulog sa ilalim ng parehong pagsubok sa puting kahon at pagsubok sa itim na kahon.

Pagsubok sa Blackbox:

Mayroong maraming mga pagsubok na nabibilang sa kategoryang ito. Magfofocus ako sakunti lang, na mahalaga para malaman mo, upang maunawaan ang blog na ito:

• Pagganap / Pagsubok sa Pagtanggap: Tinitiyak nito na gumagana ang tinukoy na pagpapaandar na kinakailangan sa mga kinakailangan ng system. Ginagawa ito upang matiyak na ang naihatid na produkto ay nakakatugon sa mga kinakailangan at gumagana tulad ng inaasahan ng customer
• Pagsubok ng System: Tinitiyak nito na sa pamamagitan ng paglalagay ng software sa iba't ibang mga kapaligiran (hal., Mga Operating System) gagana pa rin ito.
• Pagsubok ng Stress: Sinusuri nito kung paano kumikilos ang system sa ilalim ng hindi kanais-nais na mga kondisyon.
• Pagsubok ng Beta: Ginagawa ito ng mga end user, isang koponan sa labas ng pag-unlad, o publiko na naglalabas ng buong pre-bersyon ng produkto na kilala bilangbetabersyon Ang layunin ng pagsubok sa beta ay upang masakop ang mga hindi inaasahang error.

Ngayon ang tamang oras para ipaliwanag ko ang pagkakaiba sa pagitan ng Patuloy na Pagsasama, Paghahatid at Pag-deploy.

Mga Pagkakaiba sa pagitan ng Patuloy na Pagsasama, Paghahatid At Pag-deploy:

Naabot ng nilalamang biswal ang utak ng isang indibidwal sa isang mas mabilis at mas madaling maunawaan na paraan kaysa sa impormasyong pangkonteksto. Kaya't magsisimula ako sa isang diagram na malinaw na nagpapaliwanag ng pagkakaiba:

Sa Patuloy na Pagsasama, ang bawat paggawa ng code ay binuo at nasubok, ngunit, wala sa isang kondisyong ilalabas. Ibig kong sabihin ang aplikasyon ng pagbuo ay hindi awtomatikong na-deploy sa mga server ng pagsubok upang mapatunayan ito gamit ang iba't ibang mga uri ng pagsubok sa Blackbox tulad ng - User Acceptance Testing (UAT).

Sa Patuloy na Paghatid, ang application ay patuloy na ipinakalat sa mga test server para sa UAT. O, masasabi mong handa ang application na mailabas sa paggawa anumang oras. Kaya, malinaw na kinakailangan ng Patuloy na Pagsasama para sa Patuloy na Paghahatid.

Ang Patuloy na Pag-deploy ay ang susunod na hakbang sa nakaraang Patuloy na Paghahatid, kung saan hindi ka lamang lumilikha ng isang maipapalit na package, ngunit talagang inilalagay mo ito sa isang awtomatikong paraan.

Hayaan mong buod ko ang mga pagkakaiba gamit ang isang talahanayan:

Sa simpleng mga termino, ang Patuloy na Pagsasama ay isang bahagi ng parehong Patuloy na Paghahatid at Patuloy na Pag-deploy. At Ang Patuloy na Pag-deploy ay tulad ng Patuloy na Paghahatid, maliban sa mga paglabas na awtomatikong nangyayari.

Alamin Kung Paano Lumikha ng Mga Pipline ng CI / CD Paggamit ng Jenkins Sa Cloud

Ngunit ang tanong ay, kung sapat na ba ang Patuloy na Pagsasama.

Bakit Kailangan namin ng Patuloy na Paghatid?

Unawain natin ito sa isang halimbawa.

Isipin na mayroong 80 mga developer na nagtatrabaho sa isang malaking proyekto. Gumagamit sila ng Patuloy na mga pipeline ng pagsasama upang mapadali ang mga awtomatikong pagbuo. Alam naming may kasamang build sa Unit Testing din ang build. Isang araw nagpasya silang i-deploy ang pinakabagong build na naipasa ang mga pagsubok sa unit sa isang environment ng pagsubok.

Ito ay dapat na isang mahabang ngunit kontroladong diskarte sa pag-deploy na isinagawa ng kanilang mga dalubhasa sa kapaligiran. Gayunpaman, tila hindi gumana ang system.

Ano ang Maaaring Malinaw na Sanhi Ng Pagkabigo?

Sa gayon, ang unang dahilan na iisipin ng karamihan sa mga tao ay mayroong ilang problema sa pagsasaayos. Tulad ng karamihan sa mga tao kahit na naisip nila ito.Gumugol sila ng maraming oras sa pagsubok upang hanapin kung ano ang mali sa pagsasaayos ng kapaligiran, ngunit hindi nila mahanap ang problema.

Ang Isang Perceptive Developer ay Kinuha Ang Isang Matalinong Diskarte:

Pagkatapos ang isa sa nakatatandang Developer ay sinubukan ang application sa kanyang development machine. Hindi rin ito gumana doon.

Humakbang siya pabalik sa mas maaga at mas naunang mga bersyon hanggang sa natagpuan niya na ang sistema ay tumigil sa paggana tatlong linggo nang mas maaga. Ang isang maliit, malabo na bug ay pumigil sa system na magsimula nang tama. Bagaman, ang proyekto ay mayroong mahusay na saklaw ng pagsubok ng yunit.Sa kabila nito, 80 mga developer, na kadalasang nagpapatakbo lamang ng mga pagsubok kaysa sa application mismo, ay hindi nakita ang problema sa loob ng tatlong linggo.

Pahayag ng Suliranin:

Nang walang pagpapatakbo ng Mga Pagsubok sa Pagtanggap sa isang tulad ng produksyon na kapaligiran, wala silang nalalaman tungkol sa kung natutugunan ng application ang mga pagtutukoy ng customer, o kung maaari itong i-deploy at mabuhay sa totoong mundo. Kung nais nila ng napapanahong puna sa mga paksang ito, dapat nilang palawakin ang saklaw ng kanilang patuloy na proseso ng pagsasama.

Hayaan mong buod ko ang mga natutunan na aralin sa pamamagitan ng pagtingin sa mga problemang nasa itaas:

• Sinusubukan lamang ng Mga Pagsubok ng Yunit ang pananaw ng isang developer ng solusyon sa isang problema. Mayroon lamang silang isang limitadong kakayahan upang patunayan na ang application ay ginagawa kung ano ito ay dapat mula sa isang pananaw ng mga gumagamit. Hindi sila sapat upangkilalanin ang totoong mga problema sa pag-andar.
• Ang pag-deploy ng application sa pagsubok na kapaligiran ay isang kumplikado, manu-manong masinsinang proseso na medyo madaling kapitan ng error.Nangangahulugan ito na ang bawat pagtatangka sa pag-deploy ay isang bagong eksperimento - isang manu-manong, proseso ng madaling kapitan ng error.

Solusyon - Patuloy na Paghahatid ng Pipeline (Pagsubok sa Awtomatikong Pagtanggap):

Kinuha nila ang Patuloy na Pagsasama (Patuloy na Paghahatid) sa susunod na hakbang at ipinakilala ang isang simpleng, awtomatikong Mga Pagsubok sa Pagtanggap na nagpatunay na tumakbo ang application at maaaring gampanan ang pinaka-pangunahing pag-andar nito.Ang karamihan ng mga pagsubok na tumatakbo sa panahon ng yugto ng Pagtanggap ng Pagtanggap ay Mga Pagganap na Pagsubok na Magagamit.

Talaga, nagtayo sila ng isang tuluy-tuloy na pipeline ng Paghahatid, upang matiyak na ang aplikasyon ay walang putol na na-deploy sa kapaligiran ng produksyon, sa pamamagitan ng pagtiyak na ang application ay gumagana nang maayos kapag na-deploy sa test server na isang kopya ng server ng produksyon.

Sapat na sa teorya, ipapakita ko sa iyo ngayon kung paano lumikha ng isang Patuloy na pipeline ng Paghahatid gamit ang Jenkins.

Patuloy na Paghahatid ng Pipeline Gamit ang Jenkins:

Dito ko gagamitin si Jenkins upang lumikha ng isang Patuloy na Paghahatid ng Pipeline, na magsasama ng mga sumusunod na gawain:

Mga hakbang na kasangkot sa Demo:

• Kinukuha ang code mula sa GitHub
• Pag-iipon ng source code
• Pagsubok ng unit at pagbuo ng mga ulat sa pagsubok sa JUnit
• Pagbalot ng application sa isang WAR file at pag-deploy nito sa Tomcat server

Paunang mga kinakailangan:

• CentOS 7 Machine
• Jenkins 2.121.1
• Pantalan
• Tomcat 7

Hakbang - 1 Pag-iipon ng Source Code:

Magsimula tayo sa pamamagitan ng unang paglikha ng isang proyekto sa Freestyle sa Jenkins. Isaalang-alang ang screenshot sa ibaba:

Bigyan ng isang pangalan ang iyong proyekto at piliin ang Freestyle Project:

Kapag nag-scroll down ka makakahanap ka ng isang pagpipilian upang magdagdag ng repository ng source code, piliin ang git at idagdag ang repository URL, sa lalagyan na iyon mayroong isang multa sa pom.xml na gagamitin namin upang maitayo ang aming proyekto. Isaalang-alang ang screenshot sa ibaba:

Ngayon ay magdaragdag kami ng isang Build Trigger. Piliin ang pagpipilian ng poll SCM, karaniwang, iko-configure namin si Jenkins upang i-poll ang repository ng GitHub pagkatapos ng bawat 5 minuto para sa mga pagbabago sa code. Isaalang-alang ang screenshot sa ibaba:

Bago ako magpatuloy, hayaan mo akong bigyan ka ng isang maliit na pagpapakilala sa Maven Build Cycle.

Ang bawat isa sa mga build lifecycle ay tinukoy ng isang iba't ibang listahan ng mga build phase, kung saan ang isang yugto ng pagbuo ay kumakatawan sa isang yugto sa lifecycle.

Ang sumusunod ay ang listahan ng mga build phase:

• patunayan - wasto ang proyekto ay tama at ang lahat ng kinakailangang impormasyon ay magagamit
• ipunin - ipunin ang source code ng proyekto
• pagsubok - subukan ang naipong source code gamit ang isang naaangkop na framework ng pagsubok ng yunit. Ang mga pagsubok na ito ay hindi dapat mangailangan ng code na nakabalot o naka-deploy
• package - kunin ang naipong code at i-package ito sa maibabahaging format, tulad ng isang JAR.
• patunayan - patakbuhin ang anumang mga pagsusuri sa mga resulta ng mga pagsubok sa pagsasama upang matiyak na natutugunan ang pamantayan sa kalidad
• i-install - i-install ang pakete sa lokal na imbakan, para magamit bilang isang pagtitiwala sa iba pang mga proyekto nang lokal
• i-deploy - tapos sa build environment, kopyahin ang pangwakas na package sa remote na imbakan para sa pagbabahagi sa iba pang mga developer at proyekto.

Maaari kong patakbuhin ang utos sa ibaba, para sa pag-iipon ng source code, pagsubok sa unit at kahit na pag-iimpake ng application sa isang file ng giyera:

mvn malinis na package

Maaari mo ring sirain ang iyong trabaho sa pagbuo sa isang bilang ng mga hakbang sa pagbuo. Ginagawa nitong mas madali upang ayusin ang mga build sa malinis, magkakahiwalay na yugto.

Kaya't magsisimula kami sa pamamagitan ng pag-iipon ng source code. Sa tab na pagbuo, mag-click sa ipataw ang mga target sa tuktok na antas ng maven at i-type ang utos sa ibaba:

magtipon

Isaalang-alang ang screenshot sa ibaba:

Hihilahin nito ang source code mula sa GitHub repository at isasama din ito (Maven Compile Phase).

Mag-click sa I-save at patakbuhin ang proyekto.

Ngayon, mag-click sa output ng console upang makita ang resulta.

Hakbang - 2 Pagsubok ng Yunit:

Ngayon ay lilikha kami ng isa pang Freestyle Project para sa pagsubok sa yunit.

Idagdag ang parehong repository URL sa tab ng pamamahala ng source code, tulad ng ginawa namin sa nakaraang trabaho.

Ngayon, sa tab na 'Buid Trigger' mag-click sa 'build pagkatapos ng iba pang mga proyekto ay naitayo'. Mayroong i-type ang pangalan ng nakaraang proyekto kung saan isinasaayos namin ang source code, at maaari kang pumili ng alinman sa mga pagpipilian sa ibaba:

• Pag-trigger lamang kung ang build ay matatag
• Pag-trigger kahit na hindi matatag ang pagbuo
• Pag-trigger kahit na nabigo ang build

Sa palagay ko ang mga pagpipilian sa itaas ay medyo nagpapaliwanag sa sarili kaya, pumili ng alinman. Isaalang-alang ang screenshot sa ibaba:

Sa tab na Bumuo, mag-click sa ipataw ang mga target sa tuktok na antas ng maven at gamitin ang utos sa ibaba:

pagsusulit

Si Jenkins ay gumagawa din ng mahusay na trabaho ng pagtulong sa iyo na ipakita ang iyong mga resulta sa pagsubok at mga uso sa resulta ng pagsubok.

Ang pamantayan ng de facto para sa pag-uulat ng pagsubok sa mundo ng Java ay isang format na XML na ginamit ng JUnit. Ginagamit din ang format na ito ng maraming iba pang mga tool sa pagsubok sa Java, tulad ng TestNG, Spock, at Easyb. Naiintindihan ni Jenkins ang format na ito, kaya kung ang iyong pagbuo ay gumagawa ng mga resulta sa pagsubok ng JUnit XML, maaaring makabuo si Jenkins ng magagandang ulat sa pagsusuri ng grapiko at mga istatistika sa mga resulta ng pagsubok sa paglipas ng panahon, at hayaan ka ring tingnan ang mga detalye ng anumang pagkabigo sa pagsubok. Sinusubaybayan din ni Jenkins kung gaano katagal tumakbo ang iyong mga pagsubok, kapwa sa buong mundo, at bawat pagsubok — maaari itong magamit kung kailangan mong subaybayan ang mga isyu sa pagganap.

Kaya ang susunod na kailangan nating gawin ay makuha ang Jenkins na panatilihin ang mga tab sa aming mga pagsubok sa yunit.

Pumunta sa seksyong Mga Pagkilos na Post-build at lagyan ng tsek ang 'I-publish ang ulat ng resulta ng pagsubok sa JUnit'. Kapag nagpatakbo ang Maven ng mga pagsubok sa yunit sa isang proyekto, awtomatiko itong bumubuo ng mga ulat sa pagsubok ng XML sa isang direktoryo na tinatawag na surefire-ulat. Kaya ipasok ang '** / target / surefire-ulat / *. Xml' sa patlang na 'Pagsubok ng mga XML'. Ang dalawang asterisk sa simula ng landas ('**') ay isang pinakamahusay na kasanayan upang gawing mas matatag ang pagsasaayos: pinapayagan nilang makita ni Jenkins ang direktoryo ng target gaano man namin mai-configure ang Jenkins upang suriin ang source code.

** / target / surefire-ulat / *. xml

Muli i-save ito at mag-click sa Bumuo Ngayon.

Ngayon, ang ulat ng JUnit ay nakasulat sa / var / lib / jenkins / workspace / test / gameoflife-core / target / surefire-reports / TEST-behavior.

Sa dashboard ng Jenkinsmaaari mo ring mapansin ang mga resulta sa pagsubok:

Hakbang - 3 Paglikha ng isang WAR File At Pag-deploy Sa Tomcat Server:

Ngayon, ang susunod na hakbang ay i-package ang aming application sa isang WAR file at i-deploy iyon sa server ng Tomcat para sa pagsubok ng Pagtanggap ng User.

Lumikha ng isa pang proyekto sa freestyle at idagdag ang URL ng mapagkukunan ng code ng repository.

Pagkatapos sa tab na pag-trigger ng build, piliin ang build kapag iba pang mga proyekto ang naitayo, isaalang-alang ang screenshot sa ibaba:

Talaga, pagkatapos ng trabaho sa pagsubok, awtomatikong magsisimula ang yugto ng paglawak.

java kung paano ito gamitin

Sa tab na build, piliin ang shell script. I-type ang utos sa ibaba upang ibalot ang application sa isang WAR file:

mvn package

Susunod na hakbang ay ang pag-deploy ng WAR file na ito sa Tomcatserver. Sa tab na 'Mga Pagkilos na Post-Build' piliin ang pag-deploy ng digmaan / tainga sa isang lalagyan. Dito, ibigay ang landas sa file ng giyera at ibigay ang path ng konteksto. Isaalang-alang ang screenshot sa ibaba:

Piliin ang mga kredensyal ng Tomcat at, pansinin ang screenshot sa itaas. Gayundin, kailangan mong ibigay ang URL ng iyong Tomcat server.

Upang magdagdag ng mga kredensyal sa Jenkins, mag-click sa pagpipiliang mga kredensyal sa dashboard ng Jenkins.

Mag-click sa System at piliin ang mga kredensyal sa buong mundo.

Pagkatapos ay makakahanap ka ng isang pagpipilian upang idagdag ang mga kredensyal. Mag-click dito at magdagdag ng mga kredensyal.

Idagdag ang mga kredensyal ng Tomcat, isaalang-alang ang screenshot sa ibaba.

Mag-click sa OK.

Ngayon sa iyong Pag-configure ng Project, idagdag ang mga kredensyal ng tomcat na naipasok mo sa nakaraang hakbang.

Mag-click sa I-save at pagkatapos ay piliin ang Bumuo Ngayon.

Pumunta sa iyong tomcat URL, kasama ang path ng konteksto, sa aking kaso ito ay http: // localhost: 8081. Idagdag ngayon ang path ng konteksto sa dulo, isaalang-alang ang nasa ibaba Screenshot:

Link - http: // localhost: 8081 / gof

Inaasahan kong naunawaan mo ang kahulugan ng path ng konteksto.

Lumikha ngayon ng isang view ng pipeline, isaalang-alang ang screenshot sa ibaba:

Mag-click sa plus icon, upang lumikha ng isang bagong view.

I-configure ang pipeline sa gusto mo, isaalang-alang ang screenshot sa ibaba:

Wala akong binago kahit ano bukod sa pagpili ng paunang trabaho. Kaya't ang aking pipeline ay magsisimula mula sa pag-ipon. Batay sa paraan ng pag-configure ko ng iba pang mga trabaho, pagkatapos mag-compile ng pagsubok at pag-deploy ay mangyayari.

Sa wakas, maaari mong subukan ang pipeline sa pamamagitan ng pag-click sa RUN. Pagkatapos ng bawat limang minuto, kung may pagbabago sa source code, ang buong pipeline ay papatayin.

Kaya't tuloy-tuloy kaming nakakalat ng aming aplikasyon sa test server para sa pagsubok ng pagtanggap ng gumagamit (UAT).

Inaasahan kong nasiyahan ka sa pagbabasa ng post na ito sa Patuloy na Paghahatid. Kung mayroon kang anumang mga pag-aalinlangan, huwag mag-atubiling ilagay ang mga ito sa seksyon ng komento sa ibaba at babalik ako sa isang pinakaunang sagot.

Upang Bumuo ng Mga Pipline ng CI / CD Kailangan Mong Magkadalubhasang Iba't ibang Kasanayan Master Ang Kinakailangan na Mga Kasanayan sa DevOps Ngayon