การผสานรวมอย่างต่อเนื่อง - คู่มือฉบับย่อ

การบูรณาการแบบต่อเนื่องเปิดตัวครั้งแรกในปี พ.ศ. 2543 ด้วยซอฟต์แวร์ที่เรียกว่า Cruise Control. ในช่วงหลายปีที่ผ่านมาการบูรณาการอย่างต่อเนื่องกลายเป็นแนวทางปฏิบัติที่สำคัญในองค์กรซอฟต์แวร์ใด ๆ นี่คือแนวทางปฏิบัติในการพัฒนาที่เรียกร้องให้ทีมพัฒนาตรวจสอบให้แน่ใจว่ามีการสร้างและการทดสอบในภายหลังสำหรับการเปลี่ยนแปลงโค้ดทุกครั้งที่เกิดขึ้นกับโปรแกรมซอฟต์แวร์ แนวคิดนี้มีจุดมุ่งหมายเพื่อขจัดปัญหาในการค้นหาปัญหาที่เกิดขึ้นในช่วงท้ายของวงจรการสร้าง แทนที่จะเป็นนักพัฒนาที่ทำงานแบบแยกส่วนและไม่ได้รวมเข้าด้วยกันอย่างเพียงพอจึงมีการนำการบูรณาการแบบต่อเนื่องมาใช้เพื่อให้แน่ใจว่าไม่มีการเปลี่ยนแปลงโค้ดและการสร้างแบบแยก

ทำไมต้องบูรณาการอย่างต่อเนื่อง?

การผสานรวมอย่างต่อเนื่องกลายเป็นส่วนสำคัญอย่างยิ่งของกระบวนการพัฒนาซอฟต์แวร์ใด ๆ กระบวนการผสานรวมอย่างต่อเนื่องจะช่วยตอบคำถามต่อไปนี้สำหรับทีมพัฒนาซอฟต์แวร์

• ส่วนประกอบซอฟต์แวร์ทั้งหมดทำงานร่วมกันตามที่ควรหรือไม่ - บางครั้งระบบอาจซับซ้อนมากจนมีหลายอินเทอร์เฟซสำหรับแต่ละส่วนประกอบ ในกรณีเช่นนี้การตรวจสอบให้แน่ใจว่าส่วนประกอบซอฟต์แวร์ทั้งหมดทำงานร่วมกันได้อย่างราบรื่น

• รหัสซับซ้อนเกินไปสำหรับวัตถุประสงค์ในการรวมหรือไม่ - หากกระบวนการรวมอย่างต่อเนื่องยังคงล้มเหลวอาจมีความเป็นไปได้ที่โค้ดจะซับซ้อนเกินไป และนี่อาจเป็นสัญญาณในการใช้รูปแบบการออกแบบที่เหมาะสมเพื่อทำให้โค้ดมีความซับซ้อนน้อยลงและดูแลรักษาได้มากขึ้น

• รหัสเป็นไปตามมาตรฐานการเข้ารหัสที่กำหนดไว้หรือไม่ - กรณีทดสอบส่วนใหญ่จะตรวจสอบเสมอว่าโค้ดเป็นไปตามมาตรฐานการเข้ารหัสที่เหมาะสม การทำแบบทดสอบอัตโนมัติหลังการสร้างอัตโนมัตินี่เป็นจุดที่ดีในการตรวจสอบว่าโค้ดตรงตามมาตรฐานการเข้ารหัสที่ต้องการทั้งหมดหรือไม่

• การทดสอบอัตโนมัติครอบคลุมรหัสเท่าใด - ไม่มีประเด็นในการทดสอบโค้ดหากกรณีทดสอบไม่ครอบคลุมฟังก์ชันที่จำเป็นของโค้ด ดังนั้นจึงเป็นแนวทางปฏิบัติที่ดีเสมอเพื่อให้แน่ใจว่ากรณีทดสอบที่เขียนขึ้นควรครอบคลุมสถานการณ์สำคัญทั้งหมดของแอปพลิเคชัน

• การทดสอบทั้งหมดประสบความสำเร็จหลังจากการเปลี่ยนแปลงครั้งล่าสุดหรือไม่? - หากการทดสอบล้มเหลวแสดงว่าไม่มีจุดใดในการดำเนินการปรับใช้โค้ดดังนั้นนี่เป็นจุดที่ดีในการตรวจสอบว่าโค้ดพร้อมที่จะย้ายไปยังขั้นตอนการปรับใช้หรือไม่

เวิร์กโฟลว์

ภาพต่อไปนี้แสดงขั้นตอนการทำงานอย่างรวดเร็วว่าเวิร์กโฟลว์การรวมอย่างต่อเนื่องทั้งหมดทำงานอย่างไรในโครงการพัฒนาซอฟต์แวร์ใด ๆ เราจะดูรายละเอียดในบทต่อ ๆ ไป

ดังนั้นจากขั้นตอนการทำงานข้างต้นโดยทั่วไปแล้วนี่คือวิธีการทำงานของกระบวนการผสานรวมอย่างต่อเนื่อง

• ขั้นแรกนักพัฒนายอมรับรหัสกับที่เก็บการควบคุมเวอร์ชัน ในขณะเดียวกันเซิร์ฟเวอร์การรวมแบบต่อเนื่องบนเครื่องสร้างการรวมจะสำรวจที่เก็บซอร์สโค้ดสำหรับการเปลี่ยนแปลง (เช่นทุกๆสองสามนาที)

• ไม่นานหลังจากการคอมมิตเกิดขึ้นเซิร์ฟเวอร์การรวมแบบต่อเนื่องจะตรวจพบว่ามีการเปลี่ยนแปลงเกิดขึ้นในที่เก็บการควบคุมเวอร์ชันดังนั้นเซิร์ฟเวอร์การผสานรวมแบบต่อเนื่องจะดึงสำเนาล่าสุดของโค้ดจากที่เก็บจากนั้นเรียกใช้สคริปต์บิลด์ซึ่งรวมซอฟต์แวร์

• เซิร์ฟเวอร์การรวมอย่างต่อเนื่องสร้างข้อเสนอแนะโดยส่งอีเมลผลลัพธ์ไปยังสมาชิกโครงการที่ระบุ

• จากนั้นจะทำการทดสอบหน่วยหากการสร้างโครงการนั้นผ่าน หากการทดสอบสำเร็จโค้ดจะพร้อมที่จะปรับใช้กับเซิร์ฟเวอร์การจัดเตรียมหรือเซิร์ฟเวอร์ที่ใช้งานจริง

• เซิร์ฟเวอร์การรวมอย่างต่อเนื่องยังคงสำรวจการเปลี่ยนแปลงในที่เก็บการควบคุมเวอร์ชันและกระบวนการทั้งหมดจะทำซ้ำ

ส่วนซอฟต์แวร์เป็นส่วนที่สำคัญที่สุดของกระบวนการบูรณาการแบบต่อเนื่อง บทนี้มุ่งเน้นไปที่ซอฟต์แวร์ซึ่งจำเป็นสำหรับกระบวนการบูรณาการต่อเนื่องทั้งหมด

ที่เก็บซอร์สโค้ด

ที่เก็บซอร์สโค้ดถูกใช้เพื่อรักษาซอร์สโค้ดทั้งหมดและการเปลี่ยนแปลงทั้งหมดที่เกิดขึ้น สองสิ่งที่ได้รับความนิยมมากที่สุดสำหรับการจัดการที่เก็บซอร์สโค้ดคือการโค่นล้มและ Git with Git เป็นระบบที่ได้รับความนิยมล่าสุด ตอนนี้เราจะดูวิธีการติดตั้ง Git ในระบบ

ความต้องการของระบบ

หน่วยความจำ	RAM 2 GB (แนะนำ)
พื้นที่ดิสก์	200 MB HDD สำหรับการติดตั้ง จำเป็นต้องมีพื้นที่เก็บข้อมูลเพิ่มเติมเพื่อจัดเก็บซอร์สโค้ดโครงการและขึ้นอยู่กับซอร์สโค้ดที่เพิ่ม
เวอร์ชันระบบปฏิบัติการ	สามารถติดตั้งบน Windows, Ubuntu / Debian, Red Hat / Fedora / CentOS, Mac OS X

การติดตั้ง Git

Step 1 - เว็บไซต์อย่างเป็นทางการสำหรับ Git คือ https://git-scm.com/. หากคุณคลิกที่ลิงค์คุณจะเข้าสู่โฮมเพจของเว็บไซต์ทางการ Git ดังที่แสดงในภาพหน้าจอต่อไปนี้

Step 2 - ในการดาวน์โหลด Git เพียงแค่เลื่อนหน้าจอลงแล้วไปที่ส่วนดาวน์โหลดแล้วคลิกดาวน์โหลด

Step 3 - คลิกลิงก์ Windows และการดาวน์โหลด Git จะเริ่มโดยอัตโนมัติ

Step 4- คลิกไฟล์. exe ที่ดาวน์โหลดมาสำหรับ Git ในกรณีของเราเรากำลังใช้ไฟล์ Git-2.6.1-64-bit.exe คลิกเรียกใช้ที่มาจะปรากฏบนหน้าจอถัดไป

Step 5 - คลิกปุ่มถัดไปที่ปรากฏบนหน้าจอต่อไปนี้

Step 6 - คลิกถัดไปในหน้าจอต่อไปนี้เพื่อยอมรับข้อตกลงใบอนุญาตทั่วไป

Step 7 - เลือกตำแหน่งสำหรับการติดตั้ง Git ของคุณ

Step 8 - คลิกถัดไปเพื่อยอมรับส่วนประกอบเริ่มต้นที่จำเป็นต้องติดตั้ง

Step 9 - เลือกตัวเลือก 'ใช้ Git จากพรอมต์คำสั่งของ Windows' เนื่องจากเรากำลังจะใช้ Git จาก Windows

Step 10 - ในหน้าจอต่อไปนี้ยอมรับการตั้งค่าเริ่มต้นของ 'Checkout Windows-style, ยอมรับการลงท้ายบรรทัดแบบ Unix' แล้วคลิก Next

Step 11 - ในหน้าจอต่อไปนี้ให้เลือกตัวเลือก 'ใช้หน้าต่างคอนโซลเริ่มต้นของ Windows' เนื่องจากเราใช้ Windows เป็นระบบในการติดตั้ง Git

ตอนนี้การติดตั้งจะเริ่มขึ้นและสามารถทำตามขั้นตอนต่อไปเพื่อกำหนดค่า Git เมื่อการติดตั้งเสร็จสมบูรณ์

การกำหนดค่า Git

เมื่อติดตั้ง Git แล้วขั้นตอนการกำหนดค่าจะต้องดำเนินการสำหรับการกำหนดค่าเริ่มต้นของ Git

สิ่งแรกที่ต้องทำคือกำหนดค่าข้อมูลประจำตัวใน Git จากนั้นกำหนดค่าชื่อผู้ใช้และอีเมล นี่เป็นสิ่งสำคัญเพราะทุกๆGit commitใช้ข้อมูลนี้และรวมเข้ากับคอมมิตที่คุณเริ่มสร้างอย่างไม่เปลี่ยนแปลง คุณสามารถทำได้โดยเปิดพรอมต์คำสั่งจากนั้นป้อนคำสั่งต่อไปนี้ -

git config –global user.name “Username”
git config –global user.email “emailid”

ภาพหน้าจอต่อไปนี้เป็นตัวอย่างเพื่อความเข้าใจที่ดีขึ้น

คำสั่งเหล่านี้จะเปลี่ยนไฟล์คอนฟิกของ Git ตามจริง เพื่อให้แน่ใจว่าการตั้งค่าของคุณมีผลคุณสามารถแสดงรายการการตั้งค่าของไฟล์การกำหนดค่า Git โดยใช้คำสั่งต่อไปนี้

git config --list

ตัวอย่างของผลลัพธ์จะแสดงในภาพหน้าจอต่อไปนี้

เซิร์ฟเวอร์การรวมอย่างต่อเนื่อง

ซอฟต์แวร์ที่สำคัญถัดไปที่จำเป็นสำหรับไปป์ไลน์การผสานรวมแบบต่อเนื่องทั้งหมดคือซอฟต์แวร์การรวมแบบต่อเนื่องเอง ต่อไปนี้เป็นซอฟต์แวร์การผสานรวมแบบต่อเนื่องที่ใช้กันมากที่สุดในอุตสาหกรรม -

• Jenkins- นี่คือซอฟต์แวร์การบูรณาการต่อเนื่องแบบโอเพ่นซอร์สซึ่งชุมชนพัฒนาจำนวนมากใช้งาน

• Jet Brains TeamCity - นี่เป็นหนึ่งในซอฟต์แวร์การผสานรวมต่อเนื่องเชิงพาณิชย์ที่ได้รับความนิยมมากที่สุดและ บริษัท ส่วนใหญ่ใช้สิ่งนี้สำหรับความต้องการการผสานรวมอย่างต่อเนื่อง

• Atlassian Bamboo- นี่คือซอฟต์แวร์การผสานรวมต่อเนื่องยอดนิยมอีกตัวหนึ่งที่จัดหาโดย บริษัท ชื่อ Atlassian Pvt จำกัด

ซอฟต์แวร์ทั้งหมดที่กล่าวถึงข้างต้นทำงานในรูปแบบเดียวกันสำหรับการผสานรวมแบบต่อเนื่อง สำหรับจุดประสงค์ของบทช่วยสอนนี้เราจะดูที่Jetbrains TeamCity สำหรับเซิร์ฟเวอร์การรวมอย่างต่อเนื่อง

การติดตั้ง TeamCity

ต่อไปนี้เป็นขั้นตอนและข้อกำหนดของระบบสำหรับการติดตั้ง Jet Brains TeamCity ในคอมพิวเตอร์ของคุณ

ความต้องการของระบบ

หน่วยความจำ	RAM 4 GB (แนะนำ)
พื้นที่ดิสก์	1 GB HDD สำหรับการติดตั้ง จำเป็นต้องมีที่เก็บข้อมูลเพิ่มเติมเพื่อจัดเก็บพื้นที่ทำงานบิลด์สำหรับแต่ละโปรเจ็กต์
เวอร์ชันระบบปฏิบัติการ	สามารถติดตั้งบน Windows, Linux, Mac OS X

การติดตั้ง

Step 1 - เว็บไซต์อย่างเป็นทางการสำหรับ TeamCity คือhttps://www.jetbrains.com/teamcity/. หากคุณคลิกลิงก์ที่ระบุคุณจะไปที่โฮมเพจของเว็บไซต์ทางการของ TeamCity ดังที่แสดงในภาพหน้าจอต่อไปนี้ คุณสามารถเรียกดูหน้าเพื่อดาวน์โหลดซอฟต์แวร์ที่จำเป็นสำหรับ TeamCity

Step 2 - ไฟล์. exe ที่ดาวน์โหลดมาถูกใช้เพื่อจุดประสงค์ในการเรียกใช้งาน TeamCity-9.1.6.exe. ดับเบิลคลิกที่ไฟล์ปฏิบัติการจากนั้นคลิกเรียกใช้ในหน้าจอถัดไปที่ปรากฏขึ้น

Step 3 - คลิกถัดไปเพื่อเริ่มการตั้งค่า

Step 4 - คลิกปุ่ม "ฉันยอมรับ" เพื่อยอมรับข้อตกลงใบอนุญาตและดำเนินการติดตั้ง

Step 5 - เลือกตำแหน่งสำหรับการติดตั้งและคลิกถัดไป

Step 6 - เลือกส่วนประกอบเริ่มต้นสำหรับการติดตั้งและคลิกถัดไป

ขั้นตอนนี้จะเริ่มกระบวนการติดตั้ง เมื่อเสร็จสิ้นกระบวนการกำหนดค่าจะตามมา

Step 7- เลือกหมายเลขพอร์ตเพื่อให้เซิร์ฟเวอร์ทำงาน ที่ดีที่สุดคือใช้พอร์ตอื่นเช่น8080.

Step 8- จากนั้นระบบจะถามว่าบัญชีใดที่ TeamCity ต้องทำงานเป็น เลือกบัญชีระบบและคลิกถัดไป

Step 9- ถัดไปจะถามถึงบริการที่ต้องเริ่มต้น ยอมรับค่าเริ่มต้นจากนั้นคลิกถัดไป

การกำหนดค่า TeamCity

เมื่อการติดตั้งเสร็จสิ้นขั้นตอนต่อไปคือการกำหนดค่า TeamCity ซอฟต์แวร์นี้สามารถเปิดได้โดยการเรียกดู URL ต่อไปนี้ในเบราว์เซอร์ -

http://locahost:8080

Step 1- ขั้นตอนแรกคือการระบุตำแหน่งของงานสร้างซึ่ง TeamCity จะดำเนินการ เลือกตำแหน่งที่ต้องการแล้วคลิกปุ่มดำเนินการต่อ

Step 2- ขั้นตอนต่อไปคือการระบุฐานข้อมูลสำหรับจัดเก็บสิ่งประดิษฐ์ของ TeamCity ทั้งหมด สำหรับวัตถุประสงค์ของการกวดวิชาเราสามารถเลือกไฟล์Internal (HSQLDB)ซึ่งเป็นฐานข้อมูลภายในที่เหมาะสมที่สุดเมื่อใช้ผลิตภัณฑ์เพื่อการทดสอบ

จากนั้น TeamCity จะดำเนินการตามขั้นตอนที่จำเป็นทั้งหมดเพื่อเริ่มต้นใช้งาน

Step 3- ถัดไปคุณจะถูกขอให้ยอมรับข้อตกลงใบอนุญาต ยอมรับแบบเดียวกันแล้วคลิกดำเนินการต่อ

Step 4- คุณต้องสร้างบัญชีผู้ดูแลระบบที่จะใช้ในการเข้าสู่ระบบซอฟต์แวร์ TeamCity ป้อนรายละเอียดที่จำเป็นแล้วคลิกปุ่ม "สร้างบัญชี"

ตอนนี้คุณจะเข้าสู่ TeamCity

เครื่องมือสร้าง

เครื่องมือสร้างเป็นเครื่องมือที่ช่วยให้มั่นใจได้ว่าโปรแกรมถูกสร้างขึ้นในลักษณะเฉพาะ โดยปกติเครื่องมือจะแสดงรายการงานซึ่งจำเป็นสำหรับโปรแกรมที่จะสร้างขึ้นในลักษณะที่เหมาะสม เนื่องจากในตัวอย่างของเราเราจะดูไฟล์.Net program เราจะมาดูกัน MSBuildเป็นเครื่องมือสร้าง เครื่องมือ MSBuild จะดูไฟล์บิลด์ซึ่งมีรายการงานที่ใช้ในการสร้างโปรเจ็กต์ ลองดูไฟล์ Build ทั่วไปสำหรับโครงการกำหนดค่าเว็บ

ต่อไปนี้เป็นส่วนสำคัญของไฟล์ Build ซึ่งจำเป็นต้องพิจารณา

การตั้งค่า IIS

การตั้งค่าต่อไปนี้ใช้เพื่อกำหนดหมายเลขพอร์ตเส้นทางบนเว็บเซิร์ฟเวอร์คืออะไรและต้องมีการตรวจสอบสิทธิ์ประเภทใดเมื่อรันแอปพลิเคชัน นี่คือการตั้งค่าที่สำคัญซึ่งจะเปลี่ยนแปลงผ่านคำสั่ง MSBuild เมื่อเราเรียนรู้วิธีการปรับใช้ในภายหลังในบทช่วยสอน

<UseIIS>True</UseIIS>
<AutoAssignPort>True</AutoAssignPor>
<DevelopmentServerPort>61581</DevelopmentServerPort>
<DevelopmentServerVPath>/</DevelopmentServerVPath>
<IISUrl>http://localhost:61581/</IISUrl>
<NTLMAuthentication>False</NTLMAuthentication>

ItemGroup

สิ่งนี้ใช้เพื่อบอกเซิร์ฟเวอร์ Build ว่าอะไรคือไบนารีที่อ้างอิงทั้งหมดที่จำเป็นในการรันโปรเจ็กต์นี้

<ItemGroup>
   <Reference Include = "System.Web.ApplicationServices" />
   <Reference Include = "System.ComponentModel.DataAnnotations" />

<ItemGroup>
   <Compile Include = "App_Start\BundleConfig.cs" />
   <Compile Include = "App_Start\FilterConfig.cs" />

.Net Framework เวอร์ชัน

TargetFrameworkVersionจะบอกว่าเป็นเวอร์ชันของ. Net ที่ต้องมีเพื่อให้โปรเจ็กต์ทำงานได้ สิ่งนี้จำเป็นอย่างยิ่งเพราะหากบิลด์เซิร์ฟเวอร์ไม่มีสิ่งนี้การสร้างจะล้มเหลว

<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>

สภาพแวดล้อมการปรับใช้ - Amazon

สำหรับวัตถุประสงค์ของบทช่วยสอนนี้เราจะตรวจสอบให้แน่ใจว่าเซิร์ฟเวอร์การผสานรวมอย่างต่อเนื่องของเรามีความสามารถในการปรับใช้แอปพลิเคชันของเรากับ Amazon สำหรับสิ่งนี้เราจำเป็นต้องตรวจสอบให้แน่ใจว่ามีสิ่งประดิษฐ์ต่อไปนี้อยู่ในสถานที่

เซิร์ฟเวอร์ฐานข้อมูล

ทำตามขั้นตอนต่อไปนี้เพื่อให้แน่ใจว่าเซิร์ฟเวอร์ฐานข้อมูลอยู่ใน Amazon สำหรับการปรับใช้

Step 1 - ไปที่ Amazon Console - https://aws.amazon.com/console/.

เข้าสู่ระบบด้วยข้อมูลประจำตัวของคุณ โปรดทราบว่าคุณสามารถสมัคร ID ได้ฟรีบนเว็บไซต์ amazon ซึ่งจะช่วยให้คุณมีระดับฟรีที่ช่วยให้คุณใช้ทรัพยากรบางอย่างใน Amazon ได้โดยไม่เสียค่าใช้จ่าย

Step 2 - ไปที่ส่วน RDS เพื่อสร้างฐานข้อมูลของคุณ

Step 3 - คลิกอินสแตนซ์ในหน้าจอถัดไปที่ปรากฏขึ้น

Step 4 - คลิกไฟล์ Launch DB ตัวเลือกในหน้าจอถัดไปที่ปรากฏขึ้น

Step 5 - เลือกแท็บ SQL Server จากนั้นเลือกตัวเลือก Select สำหรับ SQL Server Express

Step 6 - ตรวจสอบให้แน่ใจว่าได้ป้อนรายละเอียดต่อไปนี้เพื่อยืนยันว่าคุณกำลังใช้ฐานข้อมูลระดับฟรีที่มีให้จาก Amazon

Step 7 - คลิกปุ่มขั้นตอนต่อไปเมื่อกรอกข้อมูลทั้งหมดแล้ว

Step 8 - ในหน้าจอถัดไปที่ปรากฏขึ้นให้ยอมรับการตั้งค่าเริ่มต้นทั้งหมดและคลิก Launch DB Instance.

Step 9- จากนั้นคุณจะเห็นหน้าจอที่แจ้งว่ากำลังเปิดใช้งานฐานข้อมูลสำเร็จ ในหน้าเดียวกันจะมีปุ่มเพื่อดูอินสแตนซ์ DB คลิกลิงก์เพื่อดูไฟล์DB Instance กำลังตั้งค่า

หลังจากเวลาผ่านไปสถานะของหน้าจอด้านบนจะเปลี่ยนไปเพื่อแจ้งว่าสร้างอินสแตนซ์ DB สำเร็จแล้ว

เว็บเซิร์ฟเวอร์

ขั้นตอนต่อไปคือการสร้างเว็บเซิร์ฟเวอร์ของคุณบน Amazon ซึ่งจะโฮสต์เว็บแอปพลิเคชัน สามารถทำได้โดยทำตามขั้นตอนต่อไปเพื่อให้สิ่งนี้เข้าที่

Step 1 - ไปที่ Amazon Console - https://aws.amazon.com/console/.

เข้าสู่ระบบด้วยข้อมูลประจำตัวของคุณ โปรดทราบว่าคุณสามารถสมัครไฟล์free id on the Amazon siteซึ่งจะช่วยให้คุณมีระดับฟรีที่ช่วยให้คุณใช้ทรัพยากรบางอย่างใน Amazon ได้โดยไม่เสียค่าใช้จ่าย

Step 2 - ไปที่ไฟล์ EC2 section เพื่อสร้างเว็บเซิร์ฟเวอร์ของคุณ

Step 3 - ในหน้าจอถัดไปคลิก Launch Instance

Step 4 - คลิก Windows - Microsoft Windows Server 2010 R2 Base.

Step 5 - เลือกไฟล์ t2.microตัวเลือกซึ่งเป็นส่วนหนึ่งของระดับฟรี คลิกNext: Configure Instance Details.

Step 6 - ยอมรับการตั้งค่าเริ่มต้นในหน้าจอถัดไปที่ปรากฏขึ้นจากนั้นเลือกตัวเลือก Next: Add Storage.

Step 7 - ยอมรับการตั้งค่าเริ่มต้นในหน้าจอถัดไปและเลือกตัวเลือก Next: Tag Instance.

Step 8 - ยอมรับการตั้งค่าเริ่มต้นในหน้าจอถัดไปและเลือกตัวเลือกของ Next: Configure Security Group.

Step 9 - ยอมรับการตั้งค่าเริ่มต้นในหน้าจอถัดไปและเลือกตัวเลือกของ Review and Launch.

Step 10 - คลิกเปิดในหน้าจอถัดไปที่ปรากฏขึ้น

Step 11- ในหน้าจอถัดไปที่ปรากฏขึ้นคุณจะได้รับแจ้งให้สร้างคู่คีย์ สิ่งนี้จะถูกใช้เพื่อล็อกอินเข้าสู่เซิร์ฟเวอร์ในภายหลัง เพียงแค่สร้างคู่คีย์แล้วคลิกLaunch Instance.

ตอนนี้อินสแตนซ์จะถูกตั้งค่าใน Amazon

มีโอกาสที่จะเกิดข้อผิดพลาดในโครงการ ด้วยการฝึกฝน CI อย่างมีประสิทธิภาพคุณจะพบว่าเกิดอะไรขึ้นในทุกขั้นตอนระหว่างทางแทนที่จะเป็นในภายหลังเมื่อโครงการเข้าสู่วงจรการพัฒนา CI ช่วยให้คุณระบุและลดความเสี่ยงเมื่อเกิดขึ้นทำให้ง่ายต่อการประเมินและรายงานเกี่ยวกับความสมบูรณ์ของโครงการตามหลักฐานที่เป็นรูปธรรม

ส่วนนี้จะเน้นไปที่ความเสี่ยงที่สามารถหลีกเลี่ยงได้โดยใช้การบูรณาการต่อเนื่อง

ในโครงการใด ๆ มีความเสี่ยงมากมายที่ต้องได้รับการจัดการ ด้วยการกำจัดความเสี่ยงก่อนหน้านี้ของวงจรการพัฒนาจะมีโอกาสน้อยกว่าที่ความเสี่ยงเหล่านี้จะกลายเป็นปัญหาในภายหลังเมื่อระบบใช้งานได้จริง

ความเสี่ยง 1 - ขาดซอฟต์แวร์ที่ปรับใช้งานได้

“It works on my machine but does not work on another”- นี่อาจเป็นหนึ่งในวลีที่พบบ่อยที่สุดในองค์กรซอฟต์แวร์ใด ๆ เนื่องจากจำนวนการเปลี่ยนแปลงที่เกิดขึ้นกับซอฟต์แวร์ที่สร้างขึ้นในแต่ละวันบางครั้งจึงมีความมั่นใจเพียงเล็กน้อยว่าการสร้างซอฟต์แวร์นั้นใช้งานได้จริงหรือไม่ ความกังวลนี้มีผลข้างเคียงสามประการดังต่อไปนี้

• มีความมั่นใจเพียงเล็กน้อยหรือแทบไม่มีเลยว่าเราสามารถสร้างซอฟต์แวร์ได้หรือไม่

• ขั้นตอนการผสานรวมที่ยาวนานก่อนส่งมอบซอฟต์แวร์ภายใน (เช่นทีมทดสอบ) หรือภายนอก (เช่นลูกค้า) ในช่วงเวลาที่ไม่มีอะไรให้ทำอีก

• ไม่สามารถผลิตและทำซ้ำงานสร้างที่ทดสอบได้

วิธีการแก้

การกำจัดการมีเพศสัมพันธ์ที่แน่นหนาระหว่าง IDE และกระบวนการสร้าง ใช้เครื่องแยกต่างหากสำหรับการรวมซอฟต์แวร์เท่านั้น ตรวจสอบให้แน่ใจว่าทุกสิ่งที่คุณต้องการในการสร้างซอฟต์แวร์มีอยู่ในที่เก็บการควบคุมเวอร์ชัน สุดท้ายสร้างระบบบูรณาการต่อเนื่อง

เซิร์ฟเวอร์การรวมแบบต่อเนื่องสามารถเฝ้าดูการเปลี่ยนแปลงในที่เก็บการควบคุมเวอร์ชันและรันสคริปต์การสร้างโครงการเมื่อตรวจพบการเปลี่ยนแปลงที่เก็บ ความสามารถของระบบ Continuous Integration สามารถเพิ่มขึ้นเพื่อรวมถึงการสร้างการทำงานผ่านการทดสอบดำเนินการตรวจสอบและปรับใช้ซอฟต์แวร์ในสภาพแวดล้อมการพัฒนาและการทดสอบ ด้วยวิธีนี้คุณจะมีซอฟต์แวร์ที่ใช้งานได้เสมอ

“Inability to synchronize with the database”- บางครั้งนักพัฒนาไม่สามารถสร้างฐานข้อมูลใหม่ได้อย่างรวดเร็วในระหว่างการพัฒนาและด้วยเหตุนี้จึงยากที่จะทำการเปลี่ยนแปลง บ่อยครั้งที่เกิดจากการแยกระหว่างทีมฐานข้อมูลและทีมพัฒนา แต่ละทีมจะมุ่งเน้นไปที่ความรับผิดชอบของตนเองและมีการทำงานร่วมกันระหว่างกันเพียงเล็กน้อย ความกังวลนี้มีผลข้างเคียงสามประการดังต่อไปนี้ -

• กลัวที่จะทำการเปลี่ยนแปลงหรือปรับโครงสร้างฐานข้อมูลหรือซอร์สโค้ด

• ความยากในการเติมฐานข้อมูลด้วยชุดข้อมูลการทดสอบที่แตกต่างกัน

• ความยากลำบากในการบำรุงรักษาสภาพแวดล้อมการพัฒนาและการทดสอบ (เช่นการพัฒนาการรวมระบบการควบคุมคุณภาพและการทดสอบ)

วิธีการแก้

วิธีแก้ปัญหาข้างต้นคือการตรวจสอบให้แน่ใจว่ามีการจัดวางตำแหน่งของฐานข้อมูลทั้งหมดในที่เก็บการควบคุมเวอร์ชัน ซึ่งหมายความว่าทุกสิ่งที่จำเป็นในการสร้างสคีมาฐานข้อมูลและข้อมูลใหม่จำเป็นต้องใช้สคริปต์การสร้างฐานข้อมูลสคริปต์การจัดการข้อมูลโพรซีเดอร์ที่จัดเก็บทริกเกอร์และสินทรัพย์ฐานข้อมูลอื่น ๆ

สร้างฐานข้อมูลและข้อมูลใหม่จากสคริปต์การสร้างของคุณโดยการวางและสร้างฐานข้อมูลและตารางของคุณใหม่ จากนั้นใช้ขั้นตอนและทริกเกอร์ที่เก็บไว้และสุดท้ายใส่ข้อมูลทดสอบ

ทดสอบ (และตรวจสอบ) ฐานข้อมูลของคุณ โดยทั่วไปคุณจะใช้การทดสอบส่วนประกอบเพื่อทดสอบฐานข้อมูลและข้อมูล ในบางกรณีคุณจะต้องเขียนการทดสอบเฉพาะฐานข้อมูล

ความเสี่ยง 2 - การค้นพบข้อบกพร่องล่าช้าในวงจรชีวิต

เนื่องจากมีการเปลี่ยนแปลงมากมายซึ่งเกิดขึ้นบ่อยครั้งโดยนักพัฒนาหลายคนในซอร์สโค้ดจึงมีโอกาสที่จะเกิดข้อบกพร่องในโค้ดที่สามารถตรวจพบได้ในภายหลังเท่านั้น ในกรณีเช่นนี้อาจทำให้เกิดผลกระทบอย่างมากเนื่องจากยิ่งตรวจพบข้อบกพร่องในซอฟต์แวร์ในภายหลังการลบข้อบกพร่องก็จะยิ่งแพงขึ้นเท่านั้น

วิธีการแก้

Regression Testing- นี่คือสิ่งที่สำคัญที่สุดของวงจรการพัฒนาซอฟต์แวร์ใด ๆ ทดสอบแล้วทดสอบอีกครั้ง หากมีการเปลี่ยนแปลงที่สำคัญในรหัสซอฟต์แวร์จำเป็นอย่างยิ่งที่จะต้องดำเนินการทดสอบทั้งหมด และสิ่งนี้สามารถทำให้เป็นอัตโนมัติได้ด้วยความช่วยเหลือของเซิร์ฟเวอร์การรวมอย่างต่อเนื่อง

Test Coverage- ไม่มีประเด็นในการทดสอบหากกรณีทดสอบไม่ครอบคลุมฟังก์ชันการทำงานทั้งหมดของโค้ด เป็นสิ่งสำคัญเพื่อให้แน่ใจว่ากรณีทดสอบที่สร้างขึ้นเพื่อทดสอบแอปพลิเคชันนั้นสมบูรณ์และมีการทดสอบเส้นทางรหัสทั้งหมด

ตัวอย่างเช่นหากคุณมีหน้าจอการเข้าสู่ระบบที่ต้องได้รับการทดสอบคุณก็ไม่สามารถมีกรณีทดสอบที่มีสถานการณ์ของการเข้าสู่ระบบสำเร็จได้ คุณจำเป็นต้องมีกรณีทดสอบเชิงลบซึ่งผู้ใช้ป้อนชื่อผู้ใช้และรหัสผ่านที่แตกต่างกันจากนั้นจะต้องดูว่าเกิดอะไรขึ้นในสถานการณ์ดังกล่าว

ความเสี่ยง 3 - ขาดการมองเห็นโครงการ

กลไกการสื่อสารด้วยตนเองจำเป็นต้องมีการประสานงานกันอย่างมากเพื่อให้แน่ใจว่ามีการเผยแพร่ข้อมูลโครงการไปยังบุคคลที่เหมาะสมในเวลาที่เหมาะสม การโน้มตัวไปหานักพัฒนาที่อยู่ข้างๆคุณและแจ้งให้พวกเขาทราบว่าบิวด์ล่าสุดอยู่ในไดรฟ์ที่แชร์นั้นค่อนข้างมีประสิทธิภาพ แต่ก็ไม่ได้ปรับขนาดได้ดีนัก

จะเกิดอะไรขึ้นหากมีนักพัฒนารายอื่นที่ต้องการข้อมูลนี้และพวกเขาหยุดพักหรือไม่สามารถใช้งานได้? หากเซิร์ฟเวอร์ล่มคุณจะได้รับการแจ้งเตือนอย่างไร? บางคนเชื่อว่าสามารถลดความเสี่ยงนี้ได้ด้วยการส่งอีเมลด้วยตนเอง อย่างไรก็ตามสิ่งนี้ไม่สามารถทำให้มั่นใจได้ว่าข้อมูลจะถูกสื่อสารไปยังบุคคลที่ถูกต้องในเวลาที่เหมาะสมเนื่องจากคุณอาจละทิ้งบุคคลที่สนใจโดยไม่ได้ตั้งใจและบางคนอาจไม่สามารถเข้าถึงอีเมลของพวกเขาได้ในเวลานั้น

วิธีการแก้

วิธีแก้ไขปัญหานี้คือเซิร์ฟเวอร์การรวมอย่างต่อเนื่องอีกครั้ง เซิร์ฟเวอร์ CI ทั้งหมดมีสิ่งอำนวยความสะดวกที่จะมีการเรียกใช้อีเมลอัตโนมัติเมื่อใดก็ตามที่การสร้างล้มเหลว ด้วยการแจ้งเตือนอัตโนมัตินี้ไปยังผู้มีส่วนได้ส่วนเสียที่สำคัญทั้งหมดจะช่วยให้มั่นใจได้ว่าทุกคนจะอยู่บนสถานะปัจจุบันของซอฟต์แวร์

ความเสี่ยง 4 - ซอฟต์แวร์คุณภาพต่ำ

มีข้อบกพร่องและมีข้อบกพร่องที่อาจเกิดขึ้น คุณสามารถมีข้อบกพร่องที่อาจเกิดขึ้นได้เมื่อซอฟต์แวร์ของคุณไม่ได้รับการออกแบบมาอย่างดีหรือหากไม่เป็นไปตามมาตรฐานโครงการหรือมีความซับซ้อนในการดูแลรักษา บางครั้งผู้คนเรียกสิ่งนี้ว่ารหัสหรือกลิ่นการออกแบบ -“ อาการที่อาจมีบางอย่างผิดปกติ”

บางคนเชื่อว่าซอฟต์แวร์คุณภาพต่ำเป็นเพียงต้นทุนโครงการรอการตัดบัญชี (หลังส่งมอบ) อาจเป็นต้นทุนโครงการที่รอการตัดบัญชี แต่ยังนำไปสู่ปัญหาอื่น ๆ อีกมากมายก่อนที่คุณจะส่งมอบซอฟต์แวร์ให้กับผู้ใช้ รหัสที่ซับซ้อนเกินไปรหัสที่ไม่เป็นไปตามสถาปัตยกรรมและรหัสที่ซ้ำกันมักจะนำไปสู่ข้อบกพร่องในซอฟต์แวร์ การค้นหารหัสและกลิ่นการออกแบบเหล่านี้ก่อนที่จะปรากฏเป็นข้อบกพร่องสามารถประหยัดทั้งเวลาและเงินและอาจนำไปสู่ซอฟต์แวร์คุณภาพสูง

วิธีการแก้

มีส่วนประกอบซอฟต์แวร์เพื่อดำเนินการตรวจสอบคุณภาพโค้ดซึ่งสามารถรวมเข้ากับซอฟต์แวร์ CI ได้ สิ่งนี้สามารถทำงานได้หลังจากสร้างโค้ดเพื่อให้แน่ใจว่าโค้ดเป็นไปตามหลักเกณฑ์การเข้ารหัสที่เหมาะสม

ระบบควบคุมเวอร์ชันหรือที่เรียกว่าการควบคุมแหล่งที่มาระบบจัดการซอร์สโค้ดหรือระบบควบคุมการแก้ไขเป็นกลไกในการเก็บรักษาไฟล์หลายเวอร์ชันดังนั้นเมื่อคุณแก้ไขไฟล์คุณจะยังสามารถเข้าถึงการแก้ไขก่อนหน้านี้ได้

ระบบควบคุมเวอร์ชันแรกที่เป็นที่นิยมคือเครื่องมือ UNIX ที่เป็นกรรมสิทธิ์ซึ่งเรียกว่า SCCS(Source Code Control System) ซึ่งย้อนกลับไปในปี 1970 สิ่งนี้ถูกแทนที่ด้วยRCS, ระบบควบคุมการแก้ไขและใหม่กว่า CVS, ระบบเวอร์ชันพร้อมกัน

ตอนนี้ระบบควบคุมเวอร์ชันที่นิยมใช้มากที่สุดคือ Subversion และ Git. ก่อนอื่นเรามาดูเหตุผลที่เราต้องใช้ระบบควบคุมการกำหนดเวอร์ชันและต่อไปมาดูการใส่ซอร์สโค้ดของเราGit source code repository system.

วัตถุประสงค์ของระบบควบคุมเวอร์ชัน

เหตุผลหนึ่งที่เราใช้คำว่า version control ในการตั้งค่าซอร์สคอนโทรลคือการควบคุมเวอร์ชันไม่ได้มีไว้สำหรับซอร์สโค้ดเท่านั้น ทุกสิ่งประดิษฐ์ที่เกี่ยวข้องกับการสร้างซอฟต์แวร์ของคุณควรอยู่ภายใต้การควบคุมเวอร์ชัน

Developers should use it for source code - โดยค่าเริ่มต้นซอร์สโค้ดทั้งหมดจะต้องถูกเก็บไว้ในระบบควบคุมการกำหนดเวอร์ชัน

Related artefacts- ทุกระบบจะมีสิ่งประดิษฐ์ที่เกี่ยวข้องกับซอร์สโค้ดเช่นสคริปต์ฐานข้อมูลสคริปต์การสร้างและการปรับใช้เอกสารไลบรารีและไฟล์การกำหนดค่าสำหรับแอปพลิเคชันของคุณคอมไพเลอร์และชุดเครื่องมือของคุณเป็นต้น สิ่งเหล่านี้เป็นคำชมเชยกระบวนการพัฒนาและการปรับใช้ทั้งหมดและยังต้องจัดเก็บไว้ในระบบควบคุมการกำหนดเวอร์ชัน

ด้วยการจัดเก็บข้อมูลทั้งหมดสำหรับแอปพลิเคชันในการควบคุมแหล่งที่มาการสร้างสภาพแวดล้อมการทดสอบและการใช้งานจริงใหม่ที่แอปพลิเคชันของคุณทำงานอยู่จะง่ายขึ้น ซึ่งควรรวมถึงข้อมูลการกำหนดค่าสำหรับสแต็กซอฟต์แวร์ของแอปพลิเคชันของคุณและระบบปฏิบัติการที่ประกอบด้วยสภาพแวดล้อมไฟล์โซน DNS การกำหนดค่าไฟร์วอลล์และอื่น ๆ

อย่างน้อยที่สุดคุณต้องมีทุกสิ่งที่จำเป็นในการสร้างไบนารีของแอปพลิเคชันของคุณใหม่และสภาพแวดล้อมที่พวกเขาทำงาน วัตถุประสงค์คือเพื่อให้ทุกสิ่งที่อาจเปลี่ยนแปลงได้ ณ จุดใดก็ได้ในชีวิตของโครงการจัดเก็บในลักษณะที่ควบคุมได้ สิ่งนี้ช่วยให้คุณสามารถกู้คืนสแนปชอตที่แน่นอนของสถานะของระบบทั้งหมดตั้งแต่สภาพแวดล้อมการพัฒนาไปจนถึงสภาพแวดล้อมการใช้งานจริง ณ จุดใดก็ได้ในประวัติของโครงการ

การเก็บไฟล์คอนฟิกูเรชันสำหรับสภาพแวดล้อมการพัฒนาของทีมพัฒนาในการควบคุมเวอร์ชันเป็นประโยชน์ด้วยซ้ำเนื่องจากทำให้ทุกคนในทีมใช้การตั้งค่าเดียวกันได้ง่าย นักวิเคราะห์ควรจัดเก็บเอกสารข้อกำหนด ผู้ทดสอบควรเก็บสคริปต์และขั้นตอนการทดสอบไว้ในการควบคุมเวอร์ชัน ผู้จัดการโครงการควรบันทึกแผนการเผยแพร่แผนภูมิความคืบหน้าและบันทึกความเสี่ยงที่นี่

ในระยะสั้นสมาชิกทุกคนในทีมควรจัดเก็บเอกสารหรือไฟล์ที่เกี่ยวข้องกับโครงการในการควบคุมเวอร์ชัน

การทำงานกับ Git สำหรับระบบควบคุมการกำหนดเวอร์ชันซอร์สโค้ด

ในส่วนนี้จะเน้นไปที่วิธีใช้ Git เป็นระบบควบคุมการกำหนดเวอร์ชัน จะเน้นไปที่วิธีที่คุณสามารถอัปโหลดรหัสของคุณไปยังระบบควบคุมการกำหนดเวอร์ชันและจัดการการเปลี่ยนแปลงในนั้น

แอปพลิเคชันสาธิตของเรา

สำหรับจุดประสงค์ของบทช่วยสอนทั้งหมดนี้เราจะดูง่ายๆ Web ASP.Netแอปพลิเคชันที่จะใช้สำหรับกระบวนการรวมอย่างต่อเนื่องทั้งหมด เราไม่จำเป็นต้องให้ความสำคัญกับรายละเอียดโค้ดทั้งหมดสำหรับแบบฝึกหัดนี้เพียงแค่มีภาพรวมของสิ่งที่โครงการทำก็เพียงพอแล้วสำหรับการทำความเข้าใจกระบวนการผสานรวมอย่างต่อเนื่องทั้งหมด แอปพลิเคชัน. Net นี้สร้างขึ้นโดยใช้ไฟล์Visual Studio Integrated Development Environment.

ภาพหน้าจอต่อไปนี้เป็นโครงสร้างของโซลูชันในสภาพแวดล้อม Visual Studio เป็นเว็บแอปพลิเคชันที่เรียบง่ายมากซึ่งมีรหัสหลักอยู่ในไฟล์Demo.aspx ไฟล์.

โค้ดในไฟล์ Demo.aspx จะแสดงในโปรแกรมต่อไปนี้ -

<html xmlns = "http://www.w3.org/1999/xhtml">
   <head runat = "server">
      <title>TutorialsPoint</title>
   </head>
   
   <body>
      <form id = "form1" runat="server">
         <div><%Response.Write("Continuous Integration"); %></div>
      </form>
   </body>
   
</html>

โค้ดนี้ง่ายมากและเพียงแค่ส่งออกสตริง“ Continuous Integration” ไปยังเบราว์เซอร์

เมื่อคุณเรียกใช้โปรเจ็กต์ใน Google Chrome ผลลัพธ์จะเป็นดังที่แสดงในภาพหน้าจอต่อไปนี้

การย้าย Source Code ไปที่ Git

เราจะแสดงวิธีการย้ายซอร์สโค้ดไปยัง Git จากอินเทอร์เฟซบรรทัดคำสั่งเพื่อให้ผู้ใช้ทราบถึงวิธีการใช้ Git ที่ชัดเจนยิ่งขึ้น

Step 1 - เริ่มต้นไฟล์ Git Repository. ไปที่พรอมต์คำสั่งไปที่โฟลเดอร์โครงการของคุณและออกคำสั่งgit init. คำสั่งนี้จะเพิ่มไฟล์ Git ที่จำเป็นลงในโฟลเดอร์โปรเจ็กต์เพื่อให้ Git รับรู้ได้เมื่อต้องอัปโหลดไปยังที่เก็บ

Step 2- การเพิ่มไฟล์ของคุณซึ่งจำเป็นต้องเพิ่มลงในที่เก็บ Git ซึ่งสามารถทำได้โดยการออกไฟล์git add command. ตัวเลือก dot บอก Git ว่าต้องเพิ่มไฟล์ทั้งหมดในโฟลเดอร์โปรเจ็กต์ลงในที่เก็บ Git

Step 3- ขั้นตอนสุดท้ายคือการคอมมิตไฟล์โปรเจ็กต์ไปยังที่เก็บ Git ขั้นตอนนี้จำเป็นเพื่อให้แน่ใจว่าไฟล์ทั้งหมดเป็นส่วนหนึ่งของ Git แล้ว คำสั่งที่จะออกมีให้ในภาพหน้าจอต่อไปนี้ –m option คือการแสดงความคิดเห็นเกี่ยวกับการอัปโหลดไฟล์

ตอนนี้โซลูชันของคุณพร้อมใช้งานแล้วใน Git

ต่อไปนี้เป็นคุณสมบัติหลักบางประการหรือแนวทางปฏิบัติสำหรับการผสานรวมอย่างต่อเนื่อง

• Maintain a single source repository- ซอร์สโค้ดทั้งหมดจะถูกเก็บรักษาไว้ในที่เก็บเดียว เพื่อหลีกเลี่ยงไม่ให้ซอร์สโค้ดกระจัดกระจายไปตามสถานที่ต่างๆ เครื่องมือต่างๆเช่นSubversion and Git เป็นเครื่องมือยอดนิยมในการรักษาซอร์สโค้ด

• Automate the build- การสร้างซอฟต์แวร์ควรดำเนินการในลักษณะที่สามารถทำงานได้โดยอัตโนมัติ หากมีหลายขั้นตอนที่ต้องดำเนินการเครื่องมือสร้างจะต้องสามารถทำสิ่งนี้ได้ สำหรับ. Net MSBuild เป็นเครื่องมือสร้างเริ่มต้นและสำหรับแอปพลิเคชันที่ใช้ Java คุณมีเครื่องมือเช่นMaven and Grunt.

• Make your build self-testing- โครงสร้างควรทดสอบได้ หลังจากการสร้างเกิดขึ้นโดยตรงควรเรียกใช้กรณีทดสอบเพื่อให้แน่ใจว่าสามารถทำการทดสอบสำหรับการทำงานต่างๆของซอฟต์แวร์ได้

• Every commit should build on an integration machine- เครื่องรวมเป็นเซิร์ฟเวอร์บิลด์และควรมั่นใจว่าบิวด์ทำงานบนเครื่องนี้ ซึ่งหมายความว่าส่วนประกอบที่เกี่ยวข้องทั้งหมดควรมีอยู่บนเซิร์ฟเวอร์การรวมอย่างต่อเนื่อง

• Keep the build fast- การสร้างควรเกิดขึ้นในไม่กี่นาที การสร้างไม่ควรใช้เวลาหลายชั่วโมงกว่าจะเกิดขึ้นเนื่องจากอาจหมายความว่าขั้นตอนการสร้างไม่ได้รับการกำหนดค่าอย่างเหมาะสม

• Test in a clone of the production environment- สภาพแวดล้อมการสร้างควรใกล้เคียงกับสภาพแวดล้อมการผลิต หากมีความแตกต่างอย่างมากระหว่างสภาพแวดล้อมเหล่านี้อาจมีกรณีที่บิลด์อาจล้มเหลวในการใช้งานจริงแม้ว่าจะส่งต่อบนเซิร์ฟเวอร์บิลด์

• Everyone can see what is happening - ทุกคนควรมองเห็นกระบวนการสร้างและทดสอบและปรับใช้ทั้งหมด

• Automate deployment- การผสานรวมอย่างต่อเนื่องนำไปสู่การปรับใช้อย่างต่อเนื่อง จำเป็นอย่างยิ่งเพื่อให้แน่ใจว่าบิวด์ควรจะปรับใช้กับสภาพแวดล้อมการจัดเตรียมหรือการใช้งานจริงได้ง่าย

ต่อไปนี้เป็นรายการข้อกำหนดที่สำคัญที่สุดสำหรับการผสานรวมอย่างต่อเนื่อง

• Check-In Regularly- แนวทางปฏิบัติที่สำคัญที่สุดสำหรับการผสานรวมอย่างต่อเนื่องเพื่อให้ทำงานได้อย่างถูกต้องคือการเช็คอินไปที่ trunk หรือ mainline ของที่เก็บซอร์สโค้ดบ่อยๆ การเช็คอินรหัสควรเกิดขึ้นอย่างน้อยสองสามครั้งต่อวัน การเช็คอินเป็นประจำทำให้เกิดประโยชน์อื่น ๆ มากมาย ทำให้การเปลี่ยนแปลงเล็กลงและมีโอกาสน้อยที่จะทำลายงานสร้าง หมายความว่าเวอร์ชันล่าสุดของซอฟต์แวร์ที่จะเปลี่ยนกลับเป็นที่ทราบเมื่อเกิดข้อผิดพลาดในบิลด์ต่อ ๆ ไป

  นอกจากนี้ยังช่วยให้มีวินัยมากขึ้นเกี่ยวกับการปรับโครงสร้างโค้ดและยึดติดกับการเปลี่ยนแปลงเล็ก ๆ น้อย ๆ ที่รักษาพฤติกรรม ช่วยให้มั่นใจได้ว่าการเปลี่ยนแปลงแก้ไขไฟล์จำนวนมากมีโอกาสน้อยที่จะขัดแย้งกับงานของผู้อื่น ช่วยให้นักพัฒนาสามารถใช้ประโยชน์ได้มากขึ้นลองใช้แนวคิดและทิ้งแนวคิดเหล่านี้โดยการเปลี่ยนกลับไปใช้เวอร์ชันสุดท้ายที่มุ่งมั่น

• Create a Comprehensive Automated Test Suite- หากคุณไม่มีชุดการทดสอบอัตโนมัติที่ครอบคลุมการสร้างที่ผ่านหมายความว่าแอปพลิเคชันสามารถรวบรวมและประกอบได้เท่านั้น ในขณะที่บางทีมนี่เป็นก้าวสำคัญ แต่จำเป็นอย่างยิ่งที่จะต้องมีการทดสอบอัตโนมัติในระดับหนึ่งเพื่อให้มั่นใจว่าแอปพลิเคชันของคุณใช้งานได้จริง

  โดยปกติจะมีการทดสอบ 3 ประเภทในการบูรณาการต่อเนื่อง ได้แก่ unit tests, component testsและ acceptance tests.

  การทดสอบหน่วยเขียนขึ้นเพื่อทดสอบพฤติกรรมของแอปพลิเคชันชิ้นเล็ก ๆ ของคุณโดยแยกจากกัน โดยปกติจะสามารถรันได้โดยไม่ต้องเริ่มต้นแอปพลิเคชันทั้งหมด พวกเขาไม่ตีฐานข้อมูล (หากแอปพลิเคชันของคุณมี) ระบบไฟล์หรือเครือข่าย พวกเขาไม่ต้องการให้แอปพลิเคชันของคุณทำงานในสภาพแวดล้อมที่เหมือนการผลิต การทดสอบหน่วยควรทำงานอย่างรวดเร็ว - ทั้งชุดของคุณแม้จะเป็นแอปพลิเคชันขนาดใหญ่ก็ควรจะทำงานได้ภายในสิบนาที

  การทดสอบส่วนประกอบจะทดสอบพฤติกรรมของส่วนประกอบต่างๆของแอปพลิเคชันของคุณ เช่นเดียวกับการทดสอบหน่วยพวกเขาไม่จำเป็นต้องเริ่มต้นแอปพลิเคชันทั้งหมดเสมอไป อย่างไรก็ตามอาจกระทบฐานข้อมูลระบบไฟล์หรือระบบอื่น ๆ (ซึ่งอาจถูกตัดออก) โดยทั่วไปการทดสอบส่วนประกอบจะใช้เวลานานกว่าในการรัน

• Keep the Build and Test Process Short - หากใช้เวลานานเกินไปในการสร้างโค้ดและเรียกใช้การทดสอบหน่วยคุณจะพบปัญหาต่อไปนี้

  • ผู้คนจะหยุดสร้างเวอร์ชันเต็มและจะเรียกใช้การทดสอบก่อนที่จะเช็คอิน คุณจะเริ่มได้รับการสร้างที่ล้มเหลวมากขึ้น

  • ขั้นตอนการผสานรวมอย่างต่อเนื่องจะใช้เวลานานมากจนการคอมมิตหลาย ๆ อย่างจะเกิดขึ้นเมื่อถึงเวลาที่คุณสามารถรันบิลด์อีกครั้งดังนั้นคุณจะไม่ทราบว่าการเช็คอินใดที่ทำให้บิลด์เสียหาย

  • ผู้คนจะเช็คอินน้อยลงเนื่องจากต้องนั่งรอเป็นเวลานานเพื่อรอให้ซอฟต์แวร์สร้างและการทดสอบจึงจะทำงาน

• Don’t Check-In on a Broken Build- ข้อผิดพลาดที่ใหญ่ที่สุดของการผสานรวมอย่างต่อเนื่องคือการตรวจสอบในบิลด์ที่เสียหาย หากบิวด์พังนักพัฒนาที่รับผิดชอบกำลังรอการแก้ไข พวกเขาระบุสาเหตุของการแตกหักโดยเร็วที่สุดและแก้ไขได้ หากเรานำกลยุทธ์นี้มาใช้เราจะอยู่ในตำแหน่งที่ดีที่สุดเสมอในการหาสาเหตุที่ทำให้เกิดความแตกแยกและแก้ไขทันที

  หากเพื่อนร่วมงานคนใดคนหนึ่งของเราทำการเช็คอินและมีผลทำให้บิวด์พังดังนั้นเพื่อให้มีโอกาสแก้ไขได้ดีที่สุดพวกเขาจะต้องดำเนินการแก้ไขปัญหาอย่างชัดเจน เมื่อกฎนี้ผิดกฎจะใช้เวลานานกว่าอย่างหลีกเลี่ยงไม่ได้ในการแก้ไขบิลด์ ผู้คนคุ้นเคยกับการเห็นบิลด์เสียและเร็วมากที่คุณจะเข้าสู่สถานการณ์ที่บิวด์พังตลอดเวลา

• Always Run All Commit Tests Locally Before Committing- ตรวจสอบให้แน่ใจเสมอว่าการทดสอบที่ออกแบบมาสำหรับแอปพลิเคชันนั้นถูกรันบนเครื่องโลคัลก่อนที่จะรันบนเซิร์ฟเวอร์ CI เพื่อให้แน่ใจว่ามีการเขียนกรณีการทดสอบที่ถูกต้องและหากมีความล้มเหลวในกระบวนการ CI นั่นเป็นเพราะผลการทดสอบที่ล้มเหลว

• Take Responsibility for All Breakages that Result from Your Changes- หากคุณทำการเปลี่ยนแปลงและการทดสอบทั้งหมดที่คุณเขียนผ่าน แต่คนอื่นพังงานสร้างก็ยังพัง โดยปกติจะหมายความว่าคุณได้นำเสนอข้อบกพร่องการถดถอยในแอปพลิเคชัน เป็นความรับผิดชอบของคุณเพราะคุณได้ทำการเปลี่ยนแปลง - แก้ไขการทดสอบทั้งหมดที่ไม่ผ่านอันเป็นผลมาจากการเปลี่ยนแปลงของคุณ ในบริบทของ CI สิ่งนี้ดูเหมือนชัดเจน แต่จริงๆแล้วมันไม่ใช่แนวทางปฏิบัติทั่วไปในหลาย ๆ โครงการ

มีเครื่องมือสร้างมากมายสำหรับภาษาโปรแกรมที่หลากหลาย เครื่องมือสร้างยอดนิยมบางส่วน ได้แก่Ant for Java และ MSBuild for .NET. การใช้เครื่องมือเขียนสคริปต์ที่ออกแบบมาโดยเฉพาะสำหรับการสร้างซอฟต์แวร์แทนที่จะเป็นชุดเชลล์หรือชุดสคริปต์แบบกำหนดเองเป็นวิธีที่มีประสิทธิภาพที่สุดสำหรับการพัฒนาโซลูชันบิลด์ที่สอดคล้องและทำซ้ำได้

เหตุใดเราจึงต้องมีกระบวนการสร้างเพื่อเริ่มต้นด้วย สำหรับผู้เริ่มต้นสำหรับเซิร์ฟเวอร์การผสานรวมแบบต่อเนื่องกระบวนการสร้างควรใช้งานได้ง่ายและควรใช้งานได้อย่างราบรื่น

ลองมาดูตัวอย่างง่ายๆว่าไฟล์บิวด์มีหน้าตาเป็นอย่างไรสำหรับ. Net -

<?xml version = "1.0" encoding = "utf-8"?>
<project xmlns = "http://schemas.microsoft.com/developer/msbuild/2003">
   <Target Name = "Build">
      <Message Text = "Building Project" />
      <MSBuild Projects = "project.csproj" Targets = "Build/>"
   </Target>
</project>

ต้องระบุประเด็นต่อไปนี้เกี่ยวกับโค้ดด้านบน -

• เป้าหมายถูกระบุด้วยชื่อของ Build ในกรณีนี้เป้าหมายคือชุดของขั้นตอนเชิงตรรกะที่ต้องดำเนินการในกระบวนการสร้าง คุณสามารถมีหลายเป้าหมายและมีการอ้างอิงระหว่างเป้าหมาย

• ในเป้าหมายของเราเราเก็บข้อความตัวเลือกไว้ซึ่งจะแสดงเมื่อกระบวนการสร้างเริ่มต้นขึ้น

• MSBuild task ใช้เพื่อระบุโครงการที่ต้องสร้าง. Net

ตัวอย่างข้างต้นเป็นกรณีของไฟล์สร้างที่เรียบง่ายมาก ในการผสานรวมแบบต่อเนื่องจะทำให้มั่นใจได้ว่าไฟล์นี้ได้รับการอัปเดตอยู่เสมอเพื่อให้แน่ใจว่ากระบวนการสร้างทั้งหมดนั้นราบรื่น

การสร้างโซลูชันใน. Net

เครื่องมือสร้างเริ่มต้นสำหรับ. Net คือ MSBuild และเป็นสิ่งที่มาพร้อมกับ. Net framework ขึ้นอยู่กับกรอบงานในระบบของคุณคุณจะมีเวอร์ชัน MSbuild ที่เกี่ยวข้อง ตัวอย่างเช่นหากคุณติดตั้ง. Net framework ในตำแหน่งเริ่มต้นคุณจะพบไฟล์MSBuild.exe ไฟล์ในตำแหน่งต่อไปนี้ -

C:\Windows\Microsoft.NET\Framework\v4.0.30319

มาดูกันว่าเราจะสร้างโครงการตัวอย่างของเราได้อย่างไร สมมติว่าโครงการตัวอย่างของเราอยู่ในโฟลเดอร์ที่เรียกว่าC:\Demo\Simple.

ในการใช้ MSBuild เพื่อสร้างโซลูชันข้างต้นเราจำเป็นต้องเปิดพรอมต์คำสั่งและใช้ตัวเลือก MSBuild ดังที่แสดงในโปรแกรมต่อไปนี้

msbuild C:\Demo\Simple\Simple.csproj

ในตัวอย่างข้างต้น csprojคือไฟล์โปรเจ็กต์ที่เฉพาะสำหรับ. Net ไฟล์ csproj มีข้อมูลที่เกี่ยวข้องทั้งหมดเพื่อให้แน่ใจว่ามีข้อมูลที่จำเป็นสำหรับซอฟต์แวร์ในการสร้างอย่างถูกต้อง ต่อไปนี้เป็นภาพหน้าจอของผลลัพธ์ของคำสั่ง MSBuild

คุณไม่จำเป็นต้องกังวลเกี่ยวกับคำเตือนเกี่ยวกับเอาต์พุตตราบใดที่การสร้างสำเร็จและไม่มีข้อผิดพลาด

ตอนนี้เรามาดูบางแง่มุมของไฟล์ MSBuild เพื่อดูความหมาย ประเด็นเหล่านี้เป็นสิ่งสำคัญที่ต้องทราบจากวัฏจักรการรวมอย่างต่อเนื่อง

บิลด์สคริปต์ใช้เพื่อสร้างโซลูชันซึ่งจะเป็นส่วนหนึ่งของวงจรการผสานรวมอย่างต่อเนื่องทั้งหมด ลองดูสคริปต์การสร้างทั่วไปซึ่งสร้างขึ้นเป็นส่วนหนึ่งของ Visual Studio ใน.Netสำหรับโซลูชันตัวอย่างของเรา บิลด์สคริปมีขนาดค่อนข้างใหญ่แม้จะเป็นโซลูชันง่ายๆดังนั้นเราจะอธิบายถึงส่วนที่สำคัญที่สุดของมัน ตามค่าเริ่มต้นสคริปต์การสร้างจะถูกเก็บไว้ในไฟล์ที่มีชื่อเดียวกับโซลูชันหลักใน Visual Studio ดังนั้นในกรณีของเราหากคุณเปิดไฟล์Simple.csprojคุณจะเห็นการตั้งค่าทั้งหมดที่จะใช้ในการสร้างโซลูชัน

• การพึ่งพาเวอร์ชัน MSBuild ที่ใช้ - การตั้งค่าต่อไปนี้จะใช้ไฟล์ MSBuild ที่ติดตั้งบนเซิร์ฟเวอร์ CI

<VisualStudioVersion Condition = "'$(VisualStudioVersion)' == ''">10.0</VisualStudioVersion> <VSToolsPath Condition = "'$(VSToolsPath)' == ''"> 
   $(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)
</VSToolsPath>

<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>

<Import Project = "$(MSBuildBinPath)\Microsoft.CSharp.targets" /> <Import Project = "$(VSToolsPath)\WebApplications\
   Microsoft.WebApplication.targets" Condition = "'$(VSToolsPath)' ! = ''" /> <Import Project = "$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v10.0\
   WebApplications\Microsoft.WebApplication.targets" Condition = "false" />

• ไฟล์ใดที่ต้องใช้ในการสร้างโซลูชันอย่างถูกต้อง - ไฟล์ ItemGroupแท็กจะมีไฟล์. Net ที่จำเป็นทั้งหมดซึ่งจำเป็นสำหรับการสร้างโปรเจ็กต์ให้สำเร็จ ไฟล์เหล่านี้จะต้องอยู่ในบิลด์เซิร์ฟเวอร์ตามนั้น

<ItemGroup>
   <Reference Include = "Microsoft.CSharp" />
   <Reference Include = "System.Web.DynamicData" />
   <Reference Include = "System.Web.Entity" />
   <Reference Include = "System.Web.ApplicationServices" />
   <Reference Include = "System.ComponentModel.DataAnnotations" />
   <Reference Include = "System" />
   <Reference Include = "System.Data" />
   <Reference Include = "System.Core" />
   <Reference Include = "System.Data.DataSetExtensions" />
   <Reference Include = "System.Web.Extensions" />
   <Reference Include = "System.Xml.Linq" />
   <Reference Include = "System.Drawing" />
   <Reference Include = "System.Web" />
   <Reference Include = "System.Xml" />
   <Reference Include = "System.Configuration" />
   <Reference Include = "System.Web.Services" />
   <Reference Include = "System.EnterpriseServices"/>
</ItemGroup>

• การตั้งค่าเว็บเซิร์ฟเวอร์ที่จะใช้คืออะไร - เมื่อเราไปที่หัวข้อการปรับใช้อย่างต่อเนื่องคุณจะเห็นว่า MSBuild จะถูกใช้เพื่อลบล้างการตั้งค่าเหล่านี้อย่างไรและปรับใช้กับเซิร์ฟเวอร์ที่เราเลือก

<UseIIS>True</UseIIS>
<AutoAssignPort>True</AutoAssignPort>
<DevelopmentServerPort>59495</DevelopmentServerPort>
<DevelopmentServerVPath>/</DevelopmentServerVPath>
<IISUrl></IISUrl>
<NTLMAuthentication>False</NTLMAuthentication>
<UseCustomServer>False</UseCustomServer>

ขั้นตอนที่สำคัญต่อไปคือการตรวจสอบให้แน่ใจว่าโซลูชันสร้างบนเซิร์ฟเวอร์บิลด์ ส่วนแรกเป็นขั้นตอนแบบแมนนวลเนื่องจากก่อนที่จะใช้เครื่องมือการรวมอย่างต่อเนื่องอันดับแรกเราต้องตรวจสอบให้แน่ใจว่าบิวด์ทำงานบนบิลด์เซิร์ฟเวอร์ในลักษณะเดียวกับที่ทำบนเครื่องไคลเอนต์ ในการดำเนินการนี้เราต้องดำเนินการตามขั้นตอนต่อไปนี้ -

Step 1- คัดลอกไฟล์โซลูชันทั้งหมดไปยังเซิร์ฟเวอร์ เราได้สร้างเซิร์ฟเวอร์อินสแตนซ์ของ Amazon ซึ่งจะใช้เป็นเซิร์ฟเวอร์สร้างของเรา ดังนั้นให้ทำสำเนาด้วยตนเองไปยังเซิร์ฟเวอร์ของทั้งหมด.Net โซลูชันลงบนเซิร์ฟเวอร์

Step 2- ตรวจสอบให้แน่ใจว่าเฟรมเวิร์กมีอยู่บนเซิร์ฟเวอร์ หากคุณได้รวบรวมแอปพลิเคชันของคุณใน. Net framework 4.0 บนเครื่องไคลเอนต์ของคุณคุณต้องตรวจสอบให้แน่ใจว่ามีการติดตั้งบนเครื่องเซิร์ฟเวอร์ด้วย เลยไปที่ตั้งC:\Windows\Microsoft.NET\Framework บนเซิร์ฟเวอร์ของคุณและตรวจสอบให้แน่ใจว่ามีกรอบงานที่ต้องการ

Step 3 - ตอนนี้ให้เรียกใช้ MSBuild บนเซิร์ฟเวอร์และดูว่าเกิดอะไรขึ้น

โอเคดูเหมือนว่าเราจะเกิดข้อผิดพลาด มีบทเรียนสำคัญอย่างหนึ่งในการผสานรวมอย่างต่อเนื่องและนั่นคือคุณต้องแน่ใจว่าบิวด์ทำงานบนเซิร์ฟเวอร์บิลด์ สำหรับสิ่งนี้คุณต้องแน่ใจว่าซอฟต์แวร์ที่จำเป็นต้องมีทั้งหมดได้รับการติดตั้งบนบิลด์เซิร์ฟเวอร์

สำหรับ. Net เราจำเป็นต้องติดตั้งส่วนประกอบที่เรียกว่า Visual Studio Redistributable package. แพ็คเกจนี้มีไฟล์ที่จำเป็นทั้งหมดที่จำเป็นสำหรับไฟล์.Netแอปพลิเคชันเพื่อสร้างบนเซิร์ฟเวอร์ ลองทำตามขั้นตอนการติดตั้งต่อไปนี้บนบิลด์เซิร์ฟเวอร์

Step 4 - ดับเบิลคลิกที่ไฟล์ปฏิบัติการเพื่อเริ่มการติดตั้ง

Step 5 - ในขั้นตอนถัดไปให้ยอมรับข้อกำหนดสิทธิ์การใช้งานแล้วคลิกติดตั้ง

Step 6 - ตอนนี้เมื่อเรียกใช้ MSBuild เราต้องแน่ใจว่าเรารวมพารามิเตอร์เพิ่มเติมเมื่อเรียก MSBuild ซึ่งก็คือ - p:VisualStudioversion = 12.0. เพื่อให้แน่ใจว่า MSBuild อ้างอิงไฟล์เหล่านั้นที่ดาวน์โหลดมาในขั้นตอนก่อนหน้านี้

ตอนนี้เราสามารถเห็นได้ว่าโซลูชันได้รับการสร้างขึ้นอย่างถูกต้องและเรารู้ด้วยว่าโครงการพื้นฐานของเราสร้างอย่างถูกต้องบนเซิร์ฟเวอร์

ประเด็นสำคัญถัดไปคือการตรวจสอบรหัสพื้นฐานของเราในเซิร์ฟเวอร์การจัดการที่เก็บซอร์สโค้ดซึ่งเป็น Git ในการดำเนินการนี้เราต้องทำตามขั้นตอนเหล่านี้

Step 1- เริ่มต้นที่เก็บเพื่อให้สามารถอัปโหลดไปยัง Git สิ่งนี้ทำได้ด้วยไฟล์gitคำสั่ง init ดังนั้นคุณต้องไปที่โฟลเดอร์โครงการของคุณและออกไฟล์git init คำสั่ง

Step 2- ขั้นตอนต่อไปเรียกว่าการจัดเตรียมไฟล์ใน Git สิ่งนี้เป็นการเตรียมไฟล์ทั้งหมดในโฟลเดอร์โครงการซึ่งจำเป็นต้องเพิ่มลงใน Git คุณทำสิ่งนี้กับไฟล์git addคำสั่งดังที่แสดงในภาพหน้าจอต่อไปนี้ "." สัญกรณ์ใช้เพื่อบอกว่าไฟล์ทั้งหมดในไดเร็กทอรีและไดเร็กทอรีย่อยควรรวมอยู่ในคอมมิต

Step 3 - ขั้นตอนสุดท้ายคือการคอมมิตไฟล์ไปยังที่เก็บ Git เพื่อให้ตอนนี้เป็นที่เก็บ Git แบบเต็ม

ตอนนี้เรามีซอร์สโค้ดของเราในที่เก็บ Git และโค้ดเริ่มต้นทั้งหมดของเราทำงานบนเซิร์ฟเวอร์บิลด์ได้เวลาสร้างโปรเจ็กต์ในเซิร์ฟเวอร์การรวมอย่างต่อเนื่องของเรา สามารถทำได้โดยทำตามขั้นตอนต่อไปนี้ -

Step 1- เข้าสู่ระบบซอฟต์แวร์ TeamCity ไปที่ url บนเซิร์ฟเวอร์ Continuous Integration -http://localhost:8080/login.html.

ป้อนข้อมูลรับรองของผู้ดูแลระบบและล็อกอินเข้าสู่เซิร์ฟเวอร์

Step 2- เมื่อเข้าสู่ระบบแล้วคุณจะพบกับหน้าจอหลัก คลิกCreate Project เพื่อเริ่มโครงการใหม่

Step 3- ตั้งชื่อโครงการและคลิกสร้างเพื่อเริ่มโครงการ ในกรณีของเราเราตั้งชื่อให้ว่า 'Demo' ให้กับโครงการของเราดังที่แสดงในภาพหน้าจอต่อไปนี้

Step 4- ขั้นตอนต่อไปคือการพูดถึงที่เก็บ Git ซึ่งจะใช้ในโครงการของเรา โปรดจำไว้ว่าในสภาพแวดล้อมการรวมแบบต่อเนื่องเซิร์ฟเวอร์ CI จำเป็นต้องรับรหัสจากที่เก็บที่เปิดใช้งาน Git เราได้เปิดใช้งานโฟลเดอร์โครงการของเราให้เป็นที่เก็บที่เปิดใช้งาน Git แล้วในขั้นตอนก่อนหน้านี้ ใน TeamCity คุณต้องสร้างรูท VCS สำหรับสิ่งนี้คลิกVCS Roots ในหน้าจอหลักของโครงการ

Step 5 - ในหน้าจอถัดไปให้คลิก Create VCS root ดังที่แสดงในภาพหน้าจอต่อไปนี้

Step 6 - ในหน้าจอถัดไปที่ปรากฏขึ้นให้ทำตามขั้นตอนต่อไปนี้ -

• พูดถึงประเภทของ VCS เป็น Git

• ตั้งชื่อให้กับรูท VCS ซึ่งอาจเป็นชื่อที่จำง่ายก็ได้ เราได้ให้ชื่อเป็นApp.

• ให้ Fetch url เป็น C:\Demo\Simple - นี่คือ out git เปิดใช้งานที่เก็บ

• หากคุณเลื่อนหน้าจอลงคุณจะได้รับปุ่มทดสอบการเชื่อมต่อ คลิกเพื่อให้แน่ใจว่าคุณสามารถเชื่อมต่อกับที่เก็บที่เปิดใช้งาน Git ได้สำเร็จ

Step 7 - คลิกสร้างแล้วคุณจะเห็นที่เก็บของคุณลงทะเบียนดังที่แสดงในภาพต่อไปนี้

Step 8- ขั้นตอนต่อไปคือการสร้างการกำหนดค่าการสร้างซึ่งจะใช้ในการสร้างโครงการ ไปที่หน้าจอโครงการของคุณในTeamCity → General Settings. คลิก Create Build Configuration

Step 9- ในหน้าจอต่อไปนี้ให้ตั้งชื่อสำหรับ Build Configuration ในกรณีของเราเราได้ตั้งชื่อเป็นDemoBuild จากนั้นคลิกสร้าง

Step 10 - ในหน้าจอถัดไปที่ปรากฏขึ้นคุณจะถูกขอให้เลือกไฟล์ VCS repositoryซึ่งสร้างขึ้นในขั้นตอนก่อนหน้านี้ ดังนั้นเลือกชื่อ‘App’ แล้วคลิกแนบ

Step 11- ในหน้าจอถัดไปที่ปรากฏขึ้นเราต้องกำหนดค่าขั้นตอนการสร้าง คลิกที่ปุ่ม "configure build steps manually'เชื่อมโยงหลายมิติ

Step 12 - ในหน้าจอการสร้างถัดไปเราต้องป้อนรายละเอียดต่อไปนี้ -

• เลือกประเภท Runner เป็น MSBuild

• ตั้งชื่อทางเลือกสำหรับชื่อขั้นตอน

• ตั้งชื่อไฟล์ที่ต้องสร้าง เมื่อเราระบุ MSbuild ในส่วนก่อนหน้านี้โดยปกติเราจะเห็นว่าเราให้ตัวเลือกSimple.csproj. จำเป็นต้องระบุสิ่งเดียวกันที่นี่

• เลือกเวอร์ชัน MSBuild เป็น 'Microsoft Build Tools 2013'

• เลือก MSBuild ToolsVersion เป็น 12.0.

• เลื่อนหน้าลงเพื่อบันทึกการตั้งค่า

Step 13 - ในหน้าจอถัดไปคลิกเรียกใช้

คุณจะเห็นการสร้างแอปพลิเคชันของคุณอยู่ระหว่างดำเนินการ

คุณควรได้รับหน้าจอที่ประสบความสำเร็จซึ่งเป็นสัญญาณที่ดีว่าโซลูชันของคุณกำลังสร้างอย่างถูกต้อง

คุณยังสามารถไปที่บันทึกการสร้างของคุณเพื่อดูขั้นตอนทั้งหมดที่ครอบคลุมโดยเซิร์ฟเวอร์การรวมอย่างต่อเนื่องดังที่แสดงในภาพหน้าจอต่อไปนี้

ตอนนี้เรามีรหัสพื้นฐานใน Git และลิงก์ไปยังเซิร์ฟเวอร์การผสานรวมแบบต่อเนื่องในที่สุดก็ถึงเวลาดูขั้นตอนแรกของการผสานรวมอย่างต่อเนื่อง สิ่งนี้ทำได้โดยการกำหนดงานในเซิร์ฟเวอร์การรวมอย่างต่อเนื่องเช่นทริกเกอร์ซึ่งทำให้กระบวนการรวมต่อเนื่องทั้งหมดราบรื่นที่สุด มาทำการเปลี่ยนแปลงโค้ดของเราใน Visual Studio

Step 1 - ไปที่ไฟล์ Demo.aspx หน้าใน Visual Studio และทำการเปลี่ยนแปลงชื่อของเพจ

Step 2 - หากเราสอบถามที่เก็บ Git ของเราผ่านไฟล์ git status คำสั่งคุณจะเห็นว่าไฟล์ Demo.aspx ไฟล์ถูกแก้ไข

ตอนนี้เราต้องตรวจสอบให้แน่ใจว่าการเปลี่ยนแปลงทุกครั้งในโค้ดของเราควรทำให้เกิดการสร้างในเซิร์ฟเวอร์การรวมระบบอย่างต่อเนื่อง สำหรับสิ่งนี้เราต้องทำการเปลี่ยนแปลงต่อไปนี้

Step 3 - ไปที่แดชบอร์ดโครงการของคุณแล้วคลิกส่วนทริกเกอร์แล้วคลิก Add new trigger.

Step 4 - ในหน้าจอถัดไปที่ปรากฏขึ้นให้เลือก VCS triggerซึ่งจะใช้ในการสร้างทริกเกอร์เพื่อที่เมื่อทำการเช็คอินไปยังที่เก็บบิวด์จะถูกทริกเกอร์

Step 5 - คลิก Show Advanced Options และตรวจสอบให้แน่ใจว่าได้เลือกตัวเลือกที่แสดงในภาพหน้าจอต่อไปนี้

Step 6- คลิกบันทึก ตอนนี้คุณจะเห็นทริกเกอร์ที่ลงทะเบียนเรียบร้อยแล้วดังที่แสดงในภาพหน้าจอต่อไปนี้

Step 7- ตอนนี้ถึงเวลาตรวจสอบโค้ดของเราในที่เก็บ Git แล้วดูว่าเกิดอะไรขึ้น ไปที่พรอมต์คำสั่งของเราและออกไฟล์git add คำสั่งเพื่อจัดลำดับไฟล์ที่เปลี่ยนแปลงของเรา

Step 8 - ตอนนี้ออกไฟล์ git commit คำสั่งและจะผลักดันการเปลี่ยนแปลงไปยังที่เก็บ Git

Step 9 - หากตอนนี้คุณไปที่หน้าจอภาพรวมโปรเจ็กต์ของคุณตอนนี้คุณจะเห็นบิลด์ใหม่ที่จะถูกทริกเกอร์และรัน

หากคุณเห็นไฟล์ Change log Tabคุณจะเห็นไฟล์ git comment ซึ่งทำให้เกิดการสร้าง

ลองอีกครั้ง มาทำการเปลี่ยนแปลงอีกครั้งกับไฟล์Demo.aspxไฟล์. มาดำเนินการgit add คำสั่งและ git commit คำสั่งที่มีข้อความกระทำต่อไปนี้

ตอนนี้คุณจะเห็นบิลด์ถูกทริกเกอร์โดยอัตโนมัติในแดชบอร์ดโครงการใน TeamCity

โครงสร้างจะแสดงข้อความแสดงความสำเร็จ

ตอนนี้คุณจะเห็นข้อความของ 'การกระทำที่สอง' ซึ่งถูกใช้เมื่อการเปลี่ยนแปลงเกิดขึ้นกับไฟล์ git repository.

ขณะนี้เราได้ดำเนินการในส่วนแรกของกระบวนการผสานรวมอย่างต่อเนื่องเรียบร้อยแล้ว

การแจ้งเตือนความล้มเหลวของการสร้างคือเหตุการณ์ที่เกิดขึ้นเมื่อใดก็ตามที่การสร้างล้มเหลว การแจ้งเตือนจะถูกส่งไปยังบุคคลสำคัญทุกคนเมื่อการสร้างล้มเหลว สิ่งสำคัญอันดับแรกที่ต้องทำในกรณีดังกล่าวคือเพื่อให้แน่ใจว่ามีการใช้เวลากับบิลด์ที่ล้มเหลวเพื่อให้แน่ใจว่าบิวด์ผ่าน ขั้นตอนต่อไปนี้ใช้เพื่อให้แน่ใจว่ามีการแจ้งเตือนบิลด์ใน TeamCity

ต่อไปนี้เป็นขั้นตอนในการตั้งค่าการแจ้งเตือนทางอีเมลใน TeamCity

Step 1- ใน TeamCity ไปที่แดชบอร์ดโครงการของคุณคลิกที่การดูแลระบบที่มุมขวาบน จากนั้นคุณจะเห็นไฟล์Email Notifierลิงค์ทางด้านซ้ายมือ คลิกที่ลิงค์นี้เพื่อเปิดการตั้งค่าทั่วไปสำหรับอีเมล

Step 2 - ขั้นตอนต่อไปคือการป้อนรายละเอียดของไฟล์ SMTP Server. Gmail มีสิ่งอำนวยความสะดวก SMTP ฟรีซึ่งทุกคนสามารถใช้ได้ ดังนั้นเราจึงสามารถป้อนรายละเอียดเหล่านั้นในหน้าจอถัดไปที่ปรากฏในภาพหน้าจอต่อไปนี้

• โฮสต์ SMTP - smtp.gmail.com
• พอร์ต SMTP หมายเลข - 465
• ส่งข้อความอีเมลจากและเข้าสู่ระบบ SMTP - ควรเป็นรหัส Gmail ที่ถูกต้อง
• รหัสผ่าน SMTP - รหัสผ่านที่ถูกต้องสำหรับรหัส Gmail นั้น
• การเชื่อมต่อที่ปลอดภัย - กำหนดให้เป็น SSL

Step 3 - คลิก Test Connectionเพียงเพื่อให้แน่ใจว่าการตั้งค่าทำงานอย่างถูกต้อง จากนั้นคลิกSave เพื่อบันทึกการตั้งค่า

Step 4- ขั้นตอนต่อไปคือการเปิดใช้งานการแจ้งเตือนการสร้างสำหรับผู้ใช้ งานแรกคือการสร้างผู้ใช้ซึ่งจะได้รับการแจ้งเตือนการสร้างเหล่านี้ ไปที่แดชบอร์ดโครงการของคุณและเลือกไฟล์Users Option.

Step 5- สร้างผู้ใช้ใหม่ ป้อนชื่อผู้ใช้และรหัสผ่านที่จำเป็น จากนั้นคลิกปุ่มสร้างผู้ใช้ซึ่งจะอยู่ที่ด้านล่างของหน้าจอ

Step 6 - ตอนนี้เข้าสู่ระบบ TeamCity ด้วยรหัสผู้ใช้และรหัสผ่านใหม่นี้

Step 7- หลังจากที่คุณเข้าสู่ระบบคุณจะพบกับการตั้งค่าทั่วไปของผู้ใช้ ในส่วนการแจ้งเตือนอีเมลคลิกแก้ไข

Step 8 - ในหน้าจอถัดไปที่ปรากฏขึ้นให้คลิก Add new rule.

Step 9 - ในเพิ่มกฎใหม่ให้เลือกสองตัวเลือกต่อไปนี้จากนั้นคลิกบันทึก

• สร้างจากโครงการที่เลือก - เลือกโครงการสาธิต

• เปิดใช้งานช่องทำเครื่องหมายสำหรับ "การสร้างล้มเหลว"

เมื่อเปิดใช้งานตัวเลือกทั้งสองนี้เมื่อใดก็ตามที่การสร้างล้มเหลวสำหรับโครงการสาธิตระบบจะส่งอีเมลแจ้งเตือนไปยังผู้ใช้ - demouser.

Step 10- ตอนนี้เรามาทริกเกอร์บิวด์ที่ไม่ถูกต้องเพื่อดูการทำงานนี้ ใน Visual Studio ไปที่ไฟล์demo.aspx.cs ไฟล์และใส่รหัสผิด

Step 11 - ตอนนี้เช็คอินรหัสจาก Git โดยทำไฟล์ git add และ git commit.

ตอนนี้ใน Project Dashboard บิลด์จะถูกทริกเกอร์โดยอัตโนมัติและคุณจะเห็นว่าการสร้างจะล้มเหลวดังที่แสดงในภาพหน้าจอต่อไปนี้

หากคุณเข้าสู่ระบบด้วยรหัส Gmail ของไฟล์ demouserคุณจะเห็นการแจ้งเตือนความล้มเหลวของการสร้างดังที่แสดงในภาพหน้าจอต่อไปนี้

สิ่งสำคัญประการหนึ่งของการผสานรวมแบบต่อเนื่องคือการดูว่าบิลด์ทำงานเป็นอย่างไรรวบรวมเมตริกที่สำคัญบันทึกผลลัพธ์เหล่านั้นและสร้างข้อเสนอแนะอย่างต่อเนื่องผ่านการสร้างแบบต่อเนื่อง

การมีเมตริกเหล่านี้มีประโยชน์อย่างไร

• Not Committing Code Enough- หากนักพัฒนาไม่ได้คอมมิตโค้ดกับที่เก็บการควบคุมเวอร์ชันบ่อยๆสาเหตุอาจเป็นเพราะบิวด์การรวมที่ช้า ในการเริ่มลดระยะเวลาการสร้างให้ทำการวิเคราะห์ระดับสูงของสภาพแวดล้อมบิลด์การรวมเพื่อกำหนดปัญหาคอขวด

  จากนั้นวิเคราะห์ข้อค้นพบและพิจารณาการปรับปรุงที่เหมาะสมที่สุดจากนั้นพยายามทำการเปลี่ยนแปลงในกระบวนการสร้างเพื่อลดระยะเวลาของการสร้าง สุดท้ายประเมินระยะเวลาการสร้างอีกครั้งเพื่อพิจารณาว่าการปรับปรุงเพิ่มเติมได้รับการรับประกันหรือไม่

• Improve Test Performance- แม้ในระบบ CI ที่ทำงานได้ดีเวลาในการสร้างการผสานรวมจำนวนมากจะถูกใช้โดยการดำเนินการทดสอบอัตโนมัติ การประเมินและปรับปรุงประสิทธิภาพของการทดสอบเหล่านี้สามารถลดระยะเวลาการสร้างได้อย่างมาก

• Infrastructure Issues- คุณอาจพบว่าการรวมบิวด์ช้าเนื่องจากโครงสร้างพื้นฐานของระบบ บางทีประสิทธิภาพของเครือข่ายอาจช้าหรือมีการเชื่อมต่อเครือข่ายส่วนตัวเสมือนที่ทำงานช้า

  ระบบที่กระจัดกระจายทางภูมิศาสตร์และฮาร์ดแวร์หรือซอฟต์แวร์ที่ไม่น่าเชื่อถืออาจทำให้เกิดปัญหาด้านประสิทธิภาพได้เช่นกัน ตรวจสอบและปรับปรุงทรัพยากรโครงสร้างพื้นฐานเพื่อลดระยะเวลาการสร้าง

เมตริก

ต่อไปนี้เป็นเมตริกบางส่วนที่มีอยู่ในเซิร์ฟเวอร์การรวมแบบต่อเนื่อง

มาดูกันว่า TeamCity มีอะไรให้บ้าง -

เมตริกรูปแบบหนึ่งที่ง่ายที่สุดคือสิ่งที่มีอยู่ในแดชบอร์ดโครงการ องค์ประกอบสำคัญที่นี่คือการสังเกตระยะเวลาของแต่ละบิลด์ หากระยะเวลาของแต่ละรุ่นเริ่มเพิ่มขึ้นอย่างไม่สมส่วนกับโค้ดที่สร้างขึ้นอาจเป็นปัญหาได้ ดังนั้นนี่เป็นข้อเสนอแนะอย่างหนึ่งที่สามารถนำมาใช้ได้และสาเหตุของสิ่งนี้อาจเป็นเพราะเซิร์ฟเวอร์ CI มีทรัพยากรเหลือน้อยและอาจต้องเพิ่มความจุของเซิร์ฟเวอร์

TeamCity มีสิ่งอำนวยความสะดวกในการตรวจสอบว่าเซิร์ฟเวอร์ CI มีปัญหาเกี่ยวกับโครงสร้างพื้นฐานหรือไม่ ในadmin dashboard ใน TeamCity คุณสามารถคลิกที่ Disk Usage เพื่อดูว่าแต่ละบิลด์ใช้พื้นที่ดิสก์ไปเท่าใด

หากต้องการรายละเอียดเพิ่มเติม TeamCity จะมีไฟล์ diagnostics buttonซึ่งสามารถให้ข้อมูลเพิ่มเติมเกี่ยวกับไฟล์ CPU and Memory ถูกใช้โดย CI Server

มุมมองโดยละเอียดของ Build Metrics

หากต้องการดูมุมมองโดยละเอียดของการสร้างของโครงการใดโครงการหนึ่งเมื่อเวลาผ่านไปสิ่งนี้จะพร้อมใช้งานเป็นส่วนหนึ่งของการสร้างโครงการ ในหน้าจอการสร้างโครงการไปที่หน้าจอสถิติซึ่งจะแสดงสถิติและแผนภูมิต่างๆเกี่ยวกับประสิทธิภาพของงานสร้าง

หนึ่งในคุณสมบัติที่สำคัญของการผสานรวมอย่างต่อเนื่องคือเพื่อให้แน่ใจว่าไฟล์ on-going testingเก็บรหัสทั้งหมดที่สร้างโดยเซิร์ฟเวอร์ CI หลังจากสร้างโดยเซิร์ฟเวอร์ CI แล้วจะต้องมีการตรวจสอบให้แน่ใจว่ามีกรณีทดสอบเพื่อให้ได้รับการทดสอบโค้ดที่ต้องการ เซิร์ฟเวอร์ CI ทุกตัวมีความสามารถในการเรียกใช้กรณีทดสอบหน่วยโดยเป็นส่วนหนึ่งของCI suite. ใน.Netการทดสอบหน่วยเป็นคุณลักษณะที่มีอยู่ในไฟล์ .Net framework และสิ่งเดียวกันนี้สามารถรวมเข้ากับ CI Server ได้เช่นกัน

บทนี้จะดูว่าเราสามารถกำหนดกรณีทดสอบได้อย่างไร .Netจากนั้นให้เซิร์ฟเวอร์ TeamCity ของเราเรียกใช้กรณีทดสอบนี้หลังจากการสร้างเสร็จสมบูรณ์ สำหรับสิ่งนี้อันดับแรกเราต้องแน่ใจว่าเรามีการทดสอบหน่วยที่กำหนดไว้สำหรับโครงการตัวอย่างของเรา

ในการดำเนินการนี้เราต้องปฏิบัติตามขั้นตอนต่อไปนี้ด้วยความระมัดระวังสูงสุด

Step 1- มาเพิ่มคลาสใหม่ในโซลูชันของเราซึ่งจะใช้ในการทดสอบหน่วยของเรา คลาสนี้จะมีตัวแปรชื่อซึ่งจะเก็บสตริง“ Continuous Integration” สตริงนี้จะแสดงบนหน้าเว็บ คลิกขวาที่ Simple Project และเลือกตัวเลือกเมนูAdd → Class.

Step 2 - ตั้งชื่อชั้นเรียนเป็น Tutorial.cs แล้วคลิกปุ่มเพิ่มที่ด้านล่างของหน้าจอ

Step 3- เปิดไฟล์ Tutorial.cs และเพิ่มรหัสต่อไปนี้ รหัสนี้สร้างสตริงที่เรียกว่าNameและในตัวสร้างกำหนดชื่อให้กับค่าสตริงเป็น Continuous Integration.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace Simple {
   public class Tutorial {
      public String Name;
      public Tutorial() {
         Name = "Continuous Integration";
      }
   }
}

Step 4 - ให้เราทำการเปลี่ยนแปลงกับไฟล์ Demo.aspx.csไฟล์เพื่อใช้คลาสใหม่นี้ อัปเดตโค้ดในไฟล์นี้ด้วยรหัสต่อไปนี้ ดังนั้นโค้ดนี้จะสร้างอินสแตนซ์ใหม่ของคลาสที่สร้างด้านบน

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;

namespace Simple {
   public partial class Demo : System.Web.UI.Page {
      Tutorial tp = new Tutorial();
      protected void Page_Load(object sender, EventArgs e) {
         tp.Name = "Continuous Integration";
      }
   }
}

Step 5 - ในไฟล์ demo.aspx ตอนนี้ให้เราอ้างอิงไฟล์ tp.Name ซึ่งสร้างขึ้นในไฟล์ aspx.cs ไฟล์.

<%@ Page Language = "C#" AutoEventWireup = "true" 
   CodeBehind = "Demo.aspx.cs" Inherits = "Simple.Demo" %>
<!DOCTYPE html>
<html xmlns = "http://www.w3.org/1999/xhtml">
   
   <head runat = "server">
      <title>TutorialsPoint1</title>
   </head>
   
   <body>
      <form id = "form1" runat = "server">
         <div>
            <% = tp.Name%>)
         </div>
      </form>
   </body>
   
</html>

เพื่อให้แน่ใจว่าโค้ดของเราทำงานได้ดีกับการเปลี่ยนแปลงเหล่านี้คุณสามารถเรียกใช้โค้ดใน Visual Studio คุณควรได้รับผลลัพธ์ต่อไปนี้เมื่อการคอมไพล์เสร็จสมบูรณ์

Step 6- ตอนนี้ได้เวลาเพิ่มการทดสอบหน่วยของเราในโครงการแล้ว คลิกขวาที่Solution และเลือกตัวเลือกเมนู Add → New Project.

Step 7 - ไปที่ Test และทางด้านขวามือให้เลือก Unit Test Project. ตั้งชื่อเป็นDemoTest จากนั้นคลิกตกลง

Step 8 - ในไฟล์ Demo Test projectคุณต้องเพิ่มการอ้างอิงไปยังโครงการอย่างง่ายและจำเป็น testing assemblies. คลิกขวาที่โครงการและเลือกตัวเลือกเมนูAdd Reference.

Step 9 - ในหน้าจอถัดไปที่ปรากฏขึ้นให้ไปที่โครงการเลือก Simple Reference แล้วคลิกตกลง

Step 10 - คลิก Add Reference อีกครั้งไปที่แอสเซมบลีและพิมพ์ Webในช่องค้นหา จากนั้นเพิ่มการอ้างอิงของSystem.Web.

Step 11 - ในไฟล์ Unit Test fileเพิ่มรหัสต่อไปนี้ รหัสนี้จะทำให้แน่ใจว่าคลาส Tutorial มีตัวแปรชื่อสตริง นอกจากนี้ยังเป็นการยืนยันความจริงที่ว่าชื่อควรเท่ากับค่าของ "การรวมอย่างต่อเนื่อง" นี่จะเป็นกรณีทดสอบง่ายๆของเรา

using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Microsoft.VisualStudio.TestTools.UnitTesting.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using Simple;

namespace DemoTest {
   [TestClass]
   public class UnitTest1 {
      [TestMethod]
      public void TestMethod1() {
         Tutorial tp = new Tutorial();
         Assert.AreEqual(tp.Name, "Continuous Integration");
      }
   }
}

Step 12- ตอนนี้เรามาทำการทดสอบใน Visual Studio เพื่อให้แน่ใจว่าใช้งานได้ ใน Visual Studio ให้เลือกตัวเลือกเมนูTest → Run → All Tests.

หลังจากเรียกใช้การทดสอบคุณจะเห็นการทดสอบทำงานได้สำเร็จทางด้านซ้ายมือของ Visual Studio

การเปิดใช้งานการทดสอบอย่างต่อเนื่องภายใน TeamCity - ขณะนี้กรณีการทดสอบทั้งหมดพร้อมใช้งานแล้วก็ถึงเวลารวมสิ่งเหล่านี้เข้ากับเซิร์ฟเวอร์ Team City ของเรา

Step 13- สำหรับสิ่งนี้เราต้องสร้างขั้นตอนการสร้างในการกำหนดค่าโครงการของเรา ไปที่บ้านโครงการของคุณแล้วคลิกแก้ไขการตั้งค่าการกำหนดค่า

step 14 - จากนั้นไปที่ขั้นตอนการสร้าง→ MS Build และคลิกเพิ่มขั้นตอนการสร้างตามที่แสดงในภาพหน้าจอต่อไปนี้

ในหน้าจอถัดไปที่ปรากฏขึ้นให้เพิ่มค่าต่อไปนี้ -

• เลือกประเภทนักวิ่งเป็น Visual Studio Tests

• ป้อนชื่อขั้นตอนการทดสอบเพิ่มเติม

• เลือกประเภท Test Engine เป็น VSTest.

• เลือกเวอร์ชัน Test Engine เป็น VSTest2013.

• ในชื่อไฟล์ทดสอบให้ระบุตำแหน่งเป็น DemoTest\bin\Debug\DemoTest.dll - จำไว้ DemoTestคือชื่อโครงการของเราซึ่งมีการทดสอบหน่วยของเรา DemoTest.dll จะถูกสร้างขึ้นโดยขั้นตอนการสร้างครั้งแรกของเรา

• คลิกบันทึกซึ่งจะพร้อมใช้งานที่ส่วนท้ายของหน้าจอ

ตอนนี้คุณจะมี 2 ขั้นตอนการสร้างสำหรับโครงการของคุณ ขั้นแรกคือขั้นตอนการสร้างซึ่งจะสร้างรหัสแอปพลิเคชันและโครงการทดสอบของคุณ และถัดไปจะถูกใช้เพื่อเรียกใช้กรณีทดสอบของคุณ

Step 15- ตอนนี้ถึงเวลาเช็คอินโค้ดทั้งหมดของคุณใน Git แล้วเพื่อให้สามารถเรียกใช้กระบวนการสร้างทั้งหมดได้ ข้อแตกต่างเพียงอย่างเดียวคือเวลานี้คุณต้องเรียกใช้ไฟล์git add และ git commit คำสั่งจาก Demo parent folder ดังที่แสดงในภาพหน้าจอต่อไปนี้

ตอนนี้เมื่อบิลด์ถูกทริกเกอร์คุณจะเห็นผลลัพธ์เริ่มต้นซึ่งจะบอกว่าการทดสอบผ่าน

Step 16 - หากคุณคลิกที่ผลการทดสอบที่ผ่านและไปที่แท็บการทดสอบคุณจะเห็นว่ามีการเรียกใช้งาน UnitTest1 และผ่านแล้ว

การตรวจสอบอย่างต่อเนื่องเป็นกระบวนการตรวจสอบรหัสอัตโนมัติของการตรวจสอบสำหรับรหัสของคุณก่อนที่จะดำเนินการทดสอบจริง มีความแตกต่างเล็กน้อยระหว่างการตรวจสอบและทดสอบซอฟต์แวร์ การทดสอบเป็นแบบไดนามิกและเรียกใช้ซอฟต์แวร์เพื่อทดสอบการทำงาน การตรวจสอบจะวิเคราะห์รหัสตามชุดของกฎที่กำหนดไว้ล่วงหน้า

ผู้ตรวจสอบ (หรือเครื่องมือวิเคราะห์แบบคงที่และแบบไดนามิก) ได้รับการกำหนดโดยมาตรฐานที่ระบุซึ่งทีมควรปฏิบัติตาม (โดยปกติจะเป็นเมตริกการเข้ารหัสหรือการออกแบบ) ตัวอย่างของเป้าหมายการตรวจสอบ ได้แก่ การเข้ารหัสมาตรฐาน "ไวยากรณ์" การยึดตามการแบ่งชั้นของสถาปัตยกรรมการทำสำเนาโค้ดและอื่น ๆ อีกมากมาย

การตรวจสอบอย่างต่อเนื่องช่วยลดเวลาระหว่างการค้นพบและการแก้ไข มีเครื่องมือตรวจสอบต่อเนื่องจำนวนมาก สำหรับตัวอย่างนี้เราจะใช้NCover 3.xซึ่งมีการทำงานร่วมกับ TeamCity มาดูกันว่าเราจะดำเนินการตรวจสอบอย่างต่อเนื่องได้อย่างไรและทำอะไรให้เราได้บ้าง

ดาวน์โหลดและติดตั้ง NCover

NCover เป็นผลิตภัณฑ์แยกต่างหากซึ่งจำเป็นต้องดาวน์โหลดและติดตั้ง หากต้องการดาวน์โหลด NCover โปรดคลิกที่ลิงค์ต่อไปนี้และดาวน์โหลดตัวติดตั้ง 32 บิต -http://www.ncover.com/info/download.

เรียกใช้โปรแกรมติดตั้งที่ดาวน์โหลดจากนั้นคลิกถัดไปหลังจากที่โปรแกรมติดตั้งเริ่มทำงาน

ยอมรับข้อตกลงสิทธิ์การใช้งานจากนั้นคลิกถัดไป

ยอมรับส่วนประกอบเริ่มต้นแล้วคลิกถัดไป

คลิกที่ปุ่มติดตั้งเพื่อเริ่มการติดตั้ง

คลิกปุ่ม Finish เพื่อทำการติดตั้งให้เสร็จสิ้น

เปิดการติดตั้ง NCover เป็นครั้งแรกโดยไปที่ C:\Program Files (x86)\NCover\ NCover.Explorer.exe. คุณจะต้องติดตั้งรหัสทดลองใช้เป็นครั้งแรกซึ่งเป็นกระบวนการที่ตรงไปตรงมา

กำหนดค่าโครงการใน TeamCity เพื่อใช้ NCover

Step 1 - ไปที่หน้าจอหลักโครงการของคุณแล้วคลิกแก้ไขการตั้งค่าการกำหนดค่า

Step 2 - ไปที่ขั้นตอนการสร้างและคลิกแก้ไขสำหรับไฟล์ TestStep. การตรวจสอบอย่างต่อเนื่องจำเป็นต้องดำเนินไปพร้อมกับการทดสอบหน่วยที่กำหนดไว้

Step 3 - ในส่วน. Net Coverage ให้คลิกที่ .Net Coverage Tool. จากนั้นเลือกการตั้งค่าต่อไปนี้

• เลือกเครื่องมือ. Net Coverage เป็น NCover (3.x)
• แพลตฟอร์มเป็น x86
• เวอร์ชันเป็น v4.0
• พา ธ ไปยัง NCover เป็น C: \ Program Files (x86) \ NCover
• ปล่อยให้การตั้งค่าอื่น ๆ ตามที่เป็นอยู่

Step 4 - คลิกบันทึก

Step 5 - ไปที่หน้าจอหลักของโครงการของคุณแล้วคลิกเรียกใช้

Step 6- เมื่อสร้างเสร็จแล้วให้คลิกที่การทดสอบผ่าน ตอนนี้คุณจะเห็นหน้าจอ Code Coverage และคุณจะเห็นตัวบ่งชี้เมตริกมากมาย

Step 7 - ตอนนี้คุณสามารถคลิกแท็บ Code Coverage เพื่อรับข้อมูลเพิ่มเติมเกี่ยวกับ Code Analysis

Step 8 - คลิกไฟล์ fullcoveragereport.html. ตอนนี้คุณจะได้รับรายงานฉบับสมบูรณ์เกี่ยวกับการตรวจสอบที่ดำเนินการสำหรับไฟล์.Net code.

การรวมฐานข้อมูลอย่างต่อเนื่องเป็นกระบวนการสร้างฐานข้อมูลของคุณใหม่และทดสอบข้อมูลทุกครั้งที่มีการใช้การเปลี่ยนแปลงกับที่เก็บการควบคุมเวอร์ชันของโครงการ

ในการรวมฐานข้อมูลโดยทั่วไปสิ่งประดิษฐ์ทั้งหมดที่เกี่ยวข้องกับการรวมฐานข้อมูล -

• ควรอยู่ในระบบควบคุมเวอร์ชัน
• สามารถทดสอบความเข้มงวดและตรวจสอบการปฏิบัติตามนโยบาย
• สามารถสร้างได้โดยใช้บิลด์สคริปต์ของคุณ

กิจกรรมที่สามารถมีส่วนร่วมในการรวมฐานข้อมูลแบบต่อเนื่องอาจเป็นอย่างใดอย่างหนึ่งต่อไปนี้ -

Drop a Database - วางฐานข้อมูลและลบข้อมูลที่เกี่ยวข้องเพื่อให้คุณสามารถสร้างฐานข้อมูลใหม่ด้วยชื่อเดียวกัน

Create a new Database - สร้างฐานข้อมูลใหม่โดยใช้ Data Definition Language (DDL)

Insert the Initial Data - ใส่ข้อมูลเริ่มต้น (เช่นตารางค้นหา) ที่ระบบของคุณคาดว่าจะมีเมื่อส่งมอบ

Migrate Database and Data - ย้ายสคีมาฐานข้อมูลและข้อมูลเป็นระยะ (หากคุณกำลังสร้างระบบโดยอิงจากฐานข้อมูลที่มีอยู่)

Modify Column Attributes - แก้ไขแอตทริบิวต์และข้อ จำกัด ของคอลัมน์ตารางตามข้อกำหนดและการปรับโครงสร้างใหม่

Modify Test Data - แก้ไขข้อมูลการทดสอบตามความจำเป็นสำหรับสภาพแวดล้อมที่หลากหลาย

ดังนั้นในตัวอย่างฐานข้อมูลต่อเนื่องของเราเราจะทำตามขั้นตอนต่อไปนี้ -

• เราจะสร้างฐานข้อมูล MS SQL Server และตารางที่เกี่ยวข้อง

• เราจะสร้างสคริปต์จาก SQL Server Management Studio สคริปต์ฐานข้อมูลนี้จะใช้ในการตั้งค่าตารางของเราในฐานข้อมูล

• เราจะเขียนโค้ดในโครงการ ASP.Net ของเราเพื่อเข้าถึงฐานข้อมูลนี้

• เราจะสร้างขั้นตอนในโครงการของเราใน TeamCity เพื่อเรียกใช้สคริปต์นี้

• เราจะตรวจสอบสคริปต์ของเราใน Git

ขั้นตอนในการดำเนินการนี้ในฐานข้อมูล AWS ซึ่งสร้างขึ้นในส่วนก่อนหน้านี้

Step 1- สร้างฐานข้อมูล MS SQL Server และตารางที่เกี่ยวข้อง มาเปิด SQL Server Management Studio และสร้างฐานข้อมูลและตารางอย่างง่าย คลิกขวาที่ฐานข้อมูลและคลิกที่New Database.

Step 2 - ตั้งชื่อเป็น Demodb แล้วคลิกตกลง

Step 3 - ในฐานข้อมูลใหม่ให้คลิกขวาและสร้างตารางใหม่

Step 4 - คุณสามารถเพิ่มคอลัมน์ที่คุณต้องการลงในตารางได้

Step 5 - บันทึกตารางและตั้งชื่อเป็น Demotb.

Step 6 - คลิกขวาที่ตารางแล้วเลือกตัวเลือกเมนู Script Table as → Drop and Create to → File.

Step 7 - บันทึกไฟล์ลงในโฟลเดอร์โครงการสาธิตเป็น Sample.sql.

นี่คือลักษณะของสคริปต์ฐานข้อมูล ขั้นแรกจะทิ้งตารางที่มีอยู่หากมีอยู่แล้วสร้างตารางใหม่

USE [Demodb]
GO

/****** Object: Table [dbo].[Demotb] Script Date: 3/22/2016 7:03:25 AM

******

DROP TABLE [dbo].[Demotb]
GO

/****** Object: Table [dbo].[Demotb] Script Date: 3/22/2016 7:03:25 AM

******/
SET ANSI_NULLS ON
GO

SET QUOTED_IDENTIFIER ON
GO

CREATE TABLE [dbo].[Demotb](
   [TutorialName] [nvarchar](max) NULL,
   [TutorialID] [smallint] NULL
) ON [PRIMARY] TEXTIMAGE_ON [PRIMARY]

GO

Step 8 - ตอนนี้เรามาเปลี่ยนไฟล์ ASP.Net code เพื่ออ้างถึงฐานข้อมูลใหม่

Step 9 - ในไฟล์ Tutorial.cs ไฟล์ในไฟล์ Demo projectเพิ่มโค้ดบรรทัดต่อไปนี้ โค้ดบรรทัดเหล่านี้จะเชื่อมต่อกับฐานข้อมูลของคุณใช้เวอร์ชันเซิร์ฟเวอร์และเก็บชื่อเวอร์ชันในตัวแปร Name เราสามารถแสดงตัวแปร Name นี้ในไฟล์Demo.aspx.cs ไฟล์ผ่านไฟล์ Response.write คำสั่ง

using System;
using System.Collections.Generic;
using System.Data.SqlClient;
using System.Linq;
using System.Web;

namespace Simple {
   public class Tutorial {
      public String Name;
      
      public Tutorial() {
         string connectionString = "Data Source = WIN-50GP30FGO75;
         Initial Catalog = Demodb;
         Integrated Security = true;";
         
         using (SqlConnection connection = new SqlConnection()) {
            connection.ConnectionString = connectionString;
            connection.Open();
            Name = connection.ServerVersion;
            connection.Close();
         }
      }
   }
}

Step 10 - เพิ่มรหัสต่อไปนี้ในไฟล์ Demo.aspx.cs เพื่อให้แน่ใจว่าจะแสดงเวอร์ชันของ SQL Server

using System;
using System.Collections.Generic;
using System.Data.SqlClient;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;

namespace Simple {
   public partial class Demo : System.Web.UI.Page {
      Tutorial tp = new Tutorial();
      
      protected void Page_Load(object sender, EventArgs e){
         Response.Write(tp.Name);
      }
   }
}

ตอนนี้ถ้าเรารันโค้ดคุณจะได้รับผลลัพธ์ต่อไปนี้ในเบราว์เซอร์

Step 11- ตอนนี้ให้เราเพิ่มขั้นตอนของเราใน TeamCity ซึ่งจะเรียกใช้สคริปต์ฐานข้อมูล ไปที่แดชบอร์ดโครงการของคุณแล้วคลิกEdit Configuration Settings.

Step 12 - ไปที่ขั้นตอนการสร้างและคลิก Add build step.

เลือกตัวเลือกต่อไปนี้ (โปรดทราบว่าควรติดตั้งไคลเอนต์ MS SQL Server บน CI Server)

• ประเภท Runner ควรเป็น Command Line

• ตั้งชื่อขั้นตอนที่ไม่บังคับ

• Run ควรดำเนินการได้ด้วยพารามิเตอร์

• คำสั่งปฏิบัติการควรเป็น C:\Program Files\Microsoft SQL Server\110\Tools\Binn\sqlcmd.exe

• พารามิเตอร์คำสั่งควรเป็น -S WIN-50GP30FGO75 -i Sample.sql. โดยที่ –S ให้ชื่ออินสแตนซ์ SQL Server

Step 13 - คลิกบันทึก

ตอนนี้สิ่งที่ต้องมั่นใจคือลำดับการสร้าง คุณต้องแน่ใจว่าลำดับการสร้างเป็นดังนี้

Step 14 - คุณสามารถเปลี่ยนลำดับการสร้างได้โดยเลือกตัวเลือกเพื่อเรียงลำดับขั้นตอนการสร้างใหม่

• การตั้งค่าฐานข้อมูลควรเป็นอันดับแรก - ดังนั้นสิ่งนี้จะถูกใช้เพื่อสร้างฐานข้อมูลของคุณใหม่จากสด

• ต่อไปคือการสร้างแอปพลิเคชันของคุณ

• สุดท้ายการตั้งค่าการทดสอบของคุณ

Step 15 - ตอนนี้เรียกใช้ไฟล์ git add และ git commit คำสั่งเพื่อให้ Sample.sqlไฟล์ถูกตรวจสอบใน Git สิ่งนี้จะทริกเกอร์บิวด์โดยอัตโนมัติ และงานสร้างนี้ควรผ่าน

ขณะนี้คุณมีวงจรการสร้างที่สมบูรณ์พร้อมทั้งด้านการรวมฐานข้อมูลแบบต่อเนื่องเช่นกันในวงจรของคุณ ในส่วนถัดไปเรามาดูเพิ่มเติมและดูการทำให้ใช้งานได้อย่างต่อเนื่อง

เมื่อคุณทำสิ่งนี้กับ SQL Server ในเครื่องแล้วเราสามารถทำซ้ำขั้นตอนเดียวกันสำหรับไฟล์ AWS MS SQLเซิร์ฟเวอร์ที่สร้างขึ้นในส่วนก่อนหน้านี้ ในการเชื่อมต่อกับ Microsoft SQL Server คุณต้องเชื่อมต่อผ่านหลักการดังต่อไปนี้

Step 16- ก่อนอื่นให้ดูว่าชื่อใดที่กำหนดให้กับอินสแตนซ์ฐานข้อมูลของคุณใน AWS เมื่อคุณเข้าสู่ระบบ AWS ให้ไปที่ส่วน RDS ภายใต้ส่วนฐานข้อมูล

Step 17 - คลิกที่อินสแตนซ์ DB ในหน้าจอถัดไปที่ปรากฏขึ้น

step 18- คลิกที่ฐานข้อมูลของคุณและจดบันทึกปลายทาง ในภาพหน้าจอต่อไปนี้คือdemodb.cypphcv1d87e.ap-southeast-1.rds.amazonaws.com:1433

Step 19 - ตอนนี้เพื่อเชื่อมต่อกับฐานข้อมูลจาก SQL Server Management Studioคุณต้องระบุการเชื่อมต่อเป็น demodb.cypphcv1d87e.ap-southeast-1.rds.amazonaws.com,1433 (สังเกตลูกน้ำที่ใช้ระหว่างชื่ออินสแตนซ์และหมายเลขพอร์ต)

ภาพหน้าจอต่อไปนี้แสดงการเชื่อมต่อกับฐานข้อมูลสำเร็จ

จากนั้นคุณสามารถทำซ้ำขั้นตอนเดียวกันทั้งหมด Sqlcmd command จะเป็นดังนี้ -

คำสั่งเดียวกันนี้สามารถแทนที่ได้ในขั้นตอนการสร้างฐานข้อมูลใน TeamCity เมื่อคุณรันไฟล์sqlcmd commandตารางจะถูกสร้างขึ้นโดยอัตโนมัติในฐานข้อมูล SQL Server ของคุณใน AWS

การสร้างอัตโนมัติและการสร้างที่ทำซ้ำได้ การทดสอบอัตโนมัติและการทดสอบซ้ำ ประเภทการทดสอบและความถี่ในการทดสอบ การตรวจสอบอย่างต่อเนื่อง การรวมฐานข้อมูลอย่างต่อเนื่อง สายงานเหล่านี้ในการสร้างสภาพแวดล้อม CI ที่มีประสิทธิภาพโดยหลักแล้วจะช่วยให้ได้รับประโยชน์หลักอย่างหนึ่งนั่นคือการปล่อยซอฟต์แวร์ที่ใช้งานได้ตลอดเวลาในทุกสภาพแวดล้อม

ในบทก่อนหน้านี้เราได้ทำทุกส่วนต่อไปนี้ -

• สร้างรหัสของเรา
• ตรวจสอบการสร้างที่เหมาะสมใน TeamCity
• สร้างกระบวนการรวมฐานข้อมูล
• ดำเนินการทดสอบที่ประสบความสำเร็จ

ตอนนี้สิ่งเดียวที่เหลืออยู่คือการทำให้ใช้งานได้โดยอัตโนมัติเพื่อให้กระบวนการทั้งหมดของเราเสร็จสมบูรณ์

สำหรับการปรับใช้อัตโนมัติในกรณีของเราเราจำเป็นต้องทำตามขั้นตอนเหล่านี้ -

• ในเซิร์ฟเวอร์การปรับใช้ของเราตรวจสอบให้แน่ใจว่าได้ติดตั้ง IIS แล้ว

• ตรวจสอบให้แน่ใจว่าผู้ใช้ IIS ได้รับสิทธิ์เข้าถึงฐานข้อมูลของเรา

• สร้างโปรไฟล์การเผยแพร่ซึ่งจะใช้ในการเผยแพร่ไซต์เมื่อสร้างขึ้น

• ตรวจสอบให้แน่ใจว่าเราเปลี่ยนคำสั่ง MSBuild เพื่อทำการปรับใช้อัตโนมัติ

• ทำให้ TeamCity ทำงานโดยอัตโนมัติเพื่อทำการเผยแพร่อัตโนมัติ

• ทำ git commit เพื่อให้แน่ใจว่าไฟล์ทั้งหมดของคุณอยู่ใน Git

Step 1- กำหนดค่าเซิร์ฟเวอร์ IIS ในเครื่อง หากคุณมีเซิร์ฟเวอร์ IIS แบบโลคัลหรือรีโมตการกำหนดค่าต่อไปนี้สามารถดำเนินการเพื่อปรับใช้แอปพลิเคชันของเรา เป็นแนวทางปฏิบัติที่ดีเสมอเพื่อดูว่าการปรับใช้สามารถทำได้ด้วยตนเองหรือไม่ก่อนที่จะดำเนินการโดยอัตโนมัติ

Step 2 - บนเซิร์ฟเวอร์ Windows 2012 ไปที่ Server Manager ของคุณแล้วคลิกที่ Add Roles and Features

Step 3 - คลิกถัดไปบนหน้าจอต่อไปนี้ที่ปรากฏขึ้น

Step 4 - เลือกการติดตั้งตามบทบาทหรือตามคุณลักษณะบนหน้าจอถัดไปแล้วคลิกถัดไป

Step 5 - เลือกเซิร์ฟเวอร์เริ่มต้นแล้วคลิกถัดไป

Step 6 - เลือกบทบาทเว็บเซิร์ฟเวอร์แล้วคลิกถัดไป

Step 7 - ในหน้าจอถัดไปที่ปรากฏขึ้นให้คลิกถัดไป

Step 8 - คลิกถัดไปอีกครั้งบนหน้าจอต่อไปนี้ที่ปรากฏขึ้น

Step 9 - ในหน้าจอถัดไปที่ปรากฏขึ้นให้คลิกถัดไป

Step 10 - ในหน้าจอสุดท้ายคุณสามารถคลิกปุ่มติดตั้งเพื่อติดตั้ง IIS

เมื่อคุณติดตั้ง IIS แล้วคุณสามารถเปิดได้โดยเปิด Internet Information Services

Step 11 - คลิก Application Pools คุณจะเห็นพูลที่มีชื่อของ DefaultAppPool. จำเป็นต้องมีการเข้าถึง SQL Server ในขั้นตอนถัดไป

Step 12 - หากเราต้องการเชื่อมต่อแอปพลิเคชัน ASP.Net กับแอปพลิเคชัน MS SQL Server เราต้องให้สิทธิ์การเข้าถึงพูลแอปพลิเคชันเริ่มต้นไปยังอินสแตนซ์ SQL Server เพื่อให้สามารถเชื่อมต่อกับ Demodb ฐานข้อมูล.

Step 13- เปิด Studio จัดการเซิร์ฟเวอร์ SQL ไปที่ Logins คลิกขวาแล้วเลือกตัวเลือกเมนูNew Login.

ในหน้าจอถัดไปให้อัปเดตพารามิเตอร์ต่อไปนี้แล้วคลิกตกลง

• ชื่อล็อกอินเป็น IIS APPPOOL \ DefaultAppPool
• ฐานข้อมูลเริ่มต้น - ควรเป็นฐานข้อมูลของเราซึ่งก็คือ demodb

Step 14 - การสร้างไฟล์ Publish Profile. โปรไฟล์การเผยแพร่ถูกใช้ใน Visual Studio เพื่อสร้างแพ็คเกจการปรับใช้ที่สามารถใช้กับ MS Build และในเซิร์ฟเวอร์ CI ใดก็ได้ตามนั้น ในการดำเนินการนี้จาก Visual Studio ให้คลิกขวาที่โครงการแล้วคลิกตัวเลือกเมนูของเผยแพร่

Step 15 - ในหน้าจอถัดไปที่ปรากฏขึ้นให้เลือกสร้างโปรไฟล์เผยแพร่ใหม่ตั้งชื่อ - DemoDeployment. จากนั้นคลิกปุ่มถัดไป

ในหน้าจอต่อมาที่ปรากฏขึ้นให้เพิ่มค่าต่อไปนี้ -

• เลือกวิธีการเผยแพร่เป็น Web Deploy
• เข้าสู่เซิร์ฟเวอร์เป็น localhost
• ป้อนชื่อไซต์เป็น Default Web Site / Demo
• ใส่ URL ปลายทางเป็น http://localhost/Demo

จากนั้นคลิกปุ่มถัดไป

Step 16 - ในหน้าจอถัดไปคลิกถัดไป

Step 17 - ในหน้าจอสุดท้ายที่ปรากฏขึ้นให้คลิกปุ่มเผยแพร่

ตอนนี้ถ้าคุณไปที่ไฟล์ C:\Demo\Simple\Properties\PublishProfiles ที่ตั้งโครงการของคุณคุณจะเห็นไฟล์ publish profile xml fileสร้างขึ้น ไฟล์โปรไฟล์การเผยแพร่นี้จะมีรายละเอียดทั้งหมดที่จำเป็นในการเผยแพร่แอปพลิเคชันของคุณไปยังเซิร์ฟเวอร์ IIS ภายในเครื่อง

Step 18- ตอนนี้เรามาปรับแต่งคำสั่ง MSBuild ของเราและใช้โปรไฟล์การเผยแพร่ด้านบนและดูว่าเกิดอะไรขึ้น ในคำสั่ง MSBuild ของเราเราระบุพารามิเตอร์ต่อไปนี้ -

• Deploy on Build เป็นจริง - สิ่งนี้จะทริกเกอร์การปรับใช้อัตโนมัติเมื่อบิวด์สำเร็จ

• จากนั้นเราจะกล่าวถึงการใช้โปรไฟล์การเผยแพร่ซึ่งใช้ในขั้นตอนข้างต้น

• เวอร์ชัน Visual Studio มีไว้เพื่อกล่าวถึงความสามารถในการปรับใช้ MSBuild กับเวอร์ชันของ Visual Studio ที่ใช้อยู่

เมื่อคุณเรียกใช้คำสั่งข้างต้น MSBuild จะทริกเกอร์กระบวนการสร้างและปรับใช้ สิ่งที่คุณจะทราบนั้นกำลังปรับใช้กับไฟล์Default Website ในเซิร์ฟเวอร์ IIS ของเรา

ตอนนี้ถ้าเราเรียกดูไซต์ - http://localhost/Demo/Demo.aspx เราจะเห็นผลลัพธ์ต่อไปนี้ซึ่งหมายความว่า MSBuild ทำการปรับใช้กับเว็บไซต์ของเราได้สำเร็จ

Step 19 - การทำงานอัตโนมัติผ่าน TeamCity - ตอนนี้ถึงเวลาเพิ่มงานในเซิร์ฟเวอร์ TeamCity ของเราเพื่อใช้ MSBuild เพื่อปรับใช้แอปพลิเคชันของเราโดยอัตโนมัติตามขั้นตอนที่กล่าวถึงข้างต้น

Step 20 - ไปที่แดชบอร์ดโครงการของคุณแล้วคลิก Edit Configuration Settings.

Step 21 - ไปที่ขั้นตอนการสร้างและคลิกเพิ่มขั้นตอนการสร้าง

เลือกตัวเลือกต่อไปนี้ -

• ประเภทนักวิ่งควรเป็น MSBuild

• ตั้งชื่อขั้นตอนที่ไม่บังคับ

• ป้อนเส้นทางการสร้างเป็น Simple / Simple.csproj

• เก็บเวอร์ชัน MSBuild ไว้เป็น Microsoft Build Tools 2013

• ใช้ MSBuild Toolsversion เป็น 12.0

• ใส่บรรทัดคำสั่งเป็น / p: DeployOnBuild = true / p: PublishProfile = DemoDeployement / p: VisualStudioVersion = 12.0

Step 22 - คลิกบันทึก

ตรวจสอบให้แน่ใจว่าในขั้นตอนการสร้างขั้นตอนการปรับใช้เป็นขั้นตอนสุดท้ายในห่วงโซ่

Step 23 - ทีนี้มาทำขั้นสุดท้าย git commitเพื่อให้แน่ใจว่าไฟล์ทั้งหมดอยู่ใน Git และ TeamCity สามารถใช้งานได้

ขอแสดงความยินดีคุณได้ตั้งค่าวัฏจักรการรวมอย่างต่อเนื่องที่สมบูรณ์สำหรับแอปพลิเคชันของคุณเรียบร้อยแล้วซึ่งสามารถเรียกใช้เมื่อใดก็ได้

มาทบทวนแนวทางปฏิบัติที่ดีที่สุดของการบูรณาการแบบต่อเนื่องโดยพิจารณาจากบทเรียนทั้งหมดที่เราได้เรียนรู้จนถึงตอนนี้ -

• Maintain a code repository- นี่เป็นขั้นตอนพื้นฐานที่สุด ในตัวอย่างทั้งหมดของเราทุกอย่างจะถูกเก็บรักษาไว้ในที่เก็บ Git ตั้งแต่ฐานรหัสไปจนถึงโปรไฟล์เผยแพร่ไปจนถึงสคริปต์ฐานข้อมูล ต้องมั่นใจเสมอว่าทุกอย่างจะถูกเก็บไว้ในที่เก็บโค้ด

• Automate the build- เราได้เห็นวิธีใช้ MSBuild เพื่อสร้างงานสร้างโดยอัตโนมัติพร้อมกับการใช้โปรไฟล์การเผยแพร่ นี่เป็นอีกก้าวสำคัญในกระบวนการบูรณาการอย่างต่อเนื่อง

• Make the build self-testing - ตรวจสอบให้แน่ใจว่าคุณสามารถทดสอบบิลด์ได้โดยเก็บกรณีทดสอบหน่วยไว้และกรณีทดสอบเหล่านี้ควรอยู่ในลักษณะที่สามารถรันได้โดยเซิร์ฟเวอร์การผสานรวมแบบต่อเนื่อง

• Everyone commits to the baseline every day- นี่คือหลักการสำคัญของการบูรณาการอย่างต่อเนื่อง ไม่มีประเด็นใดที่จะอยู่จนจบกระบวนการทั้งหมดเพื่อดูว่าใครทำลายงานสร้าง

• Every commit (to baseline) should be built- ทุกข้อตกลงที่ทำกับแอปพลิเคชันจะต้องสร้างให้สำเร็จ หากบิวด์ล้มเหลวไม่ว่าด้วยเหตุผลใดก็ตามจำเป็นต้องเปลี่ยนโค้ดเพื่อให้แน่ใจว่าบิวด์ผ่าน

• Keep the build fast- หากบิวด์ช้าแสดงว่ามีปัญหาในกระบวนการผสานรวมต่อเนื่องทั้งหมด ตรวจสอบให้แน่ใจว่าบิวด์ถูก จำกัด ไว้ที่ระยะเวลาเสมอโดยไม่ควรเกิน 10 นาที

• Everyone can see the results of the latest build- แดชบอร์ด TeamCity ช่วยให้ทุกคนเห็นงานสร้างทั้งหมดที่ผ่านหรือล้มเหลว สิ่งนี้ให้ข้อมูลเชิงลึกที่ดีแก่ทุกคนที่มีส่วนร่วมในกระบวนการบูรณาการอย่างต่อเนื่อง