บทเรียนการใช้ Puppet สำหรับผู้เริ่มต้น: พื้นฐานและ DSL

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

การจัดการการกำหนดค่าคืออะไร?

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

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

อย่างไรก็ตาม การทำงานในลักษณะนี้กลายเป็นเรื่องยากเมื่อต้องจัดการกับโครงสร้างพื้นฐานขนาดใหญ่ จึงมีการนำเครื่องมือจัดการการกำหนดค่า เช่น Puppet มาใช้เพื่อแก้ไขปัญหาเหล่านี้

หุ่นเชิดคืออะไร?

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

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

Puppet ได้รับการออกแบบมาเป็นพิเศษเพื่อจัดการการกำหนดค่าของ Linux และ Windows ระบบ มันเขียนด้วยภาษา Ruby และใช้เอกลักษณ์ของมัน Dละเว้น Specific Language (DSL) เพื่ออธิบายการกำหนดค่าระบบ

หุ่นกระบอกมีเวอร์ชั่นอะไรบ้าง?

หุ่นเชิดมีสองรุ่น:

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

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

หุ่นทำอะไรได้บ้าง?

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

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

หุ่นกระบอกทำหน้าที่ดังต่อไปนี้:

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

Puppet DSL และกระบวนทัศน์การเขียนโปรแกรม

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

กระบวนทัศน์สี่ประเภทคือ:

• ความจำเป็น
• ประกาศ.
• เชิงฟังก์ชัน (ซึ่งถือเป็นส่วนหนึ่งของกระบวนทัศน์เชิงประกาศ)
• เชิงวัตถุ

เราจะมุ่งเน้นไปที่รูปแบบประโยคคำสั่งและประโยคประกาศ

กระบวนทัศน์ที่จำเป็น

รูปแบบการเขียนโปรแกรมนี้แสดงถึงตรรกะของการคำนวณ (สิ่งที่ต้องทำ) และยังอธิบายถึงการควบคุมการไหลของกระบวนการ (วิธีการทำ) อีกด้วย

ตัวอย่าง:

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

กระบวนทัศน์ที่ประกาศ

รูปแบบการเขียนโปรแกรมนี้แสดงถึงตรรกะของการคำนวณ (สิ่งที่ต้องทำ) โดยไม่ต้องอธิบายขั้นตอนการควบคุม (วิธีการทำ)

ตัวอย่าง:

สมมติว่าคุณกำลังจะไปที่ทำงาน คุณเรียกรถ Uber และระบุเพียงจุดหมายปลายทางสุดท้าย (ที่ทำงาน) การระบุสิ่งที่ต้องทำ แต่ไม่ได้ระบุวิธีการทำนั้น เป็นรูปแบบการเขียนแบบประกาศ (declarative style)

ตัวอย่าง	สิ่งที่ต้องทำ	วิธีการทำ
ความจำเป็น	มี (ใบกำกับภาษีเต็มรูปแบบ)	มี (ใบกำกับภาษีเต็มรูปแบบ)
ประกาศ	มี (ใบกำกับภาษีเต็มรูปแบบ)	ไม่

Puppet ใช้กระบวนทัศน์การเขียนโปรแกรมที่ประกาศ

Puppet ใช้วิธีการเขียนโปรแกรมแบบประกาศ

ตัวอย่าง: สร้างผู้ใช้ในระบบ

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

อย่างไรก็ตาม สามารถทำได้โดยใช้รูปแบบการเขียนโปรแกรมเชิงประกาศ (declarative programming pattern) โดยใช้โค้ด Puppet เพียงไม่กี่บรรทัดและภาษาเฉพาะโดเมน (DSL) ของ Puppet เท่านั้น และยังคงได้ผลลัพธ์เดียวกัน

โมเดลการปรับใช้งานเครื่องมือการจัดการการกำหนดค่า

มีสองรูปแบบการใช้งานสำหรับ เครื่องมือการจัดการการกำหนดค่า:

• รูปแบบการใช้งานแบบพุช: เริ่มต้นโดยโหนดหลัก
• รูปแบบการใช้งานแบบดึง: เริ่มต้นโดยตัวแทน

รูปแบบการใช้งานแบบพุช

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

รูปแบบการปรับใช้แบบดึง (Pull-based deployment model)

ในรูปแบบการใช้งานนี้ เซิร์ฟเวอร์แต่ละตัวจะติดต่อกับเซิร์ฟเวอร์หลัก ตรวจสอบและสร้างการเชื่อมต่อที่ปลอดภัย ดาวน์โหลดการกำหนดค่าและซอฟต์แวร์ จากนั้นจึงกำหนดค่าตัวเองตามนั้น — ตัวอย่างเช่น Puppet และ Chef.

หุ่นเชิดทำงานอย่างไร?

Puppet ใช้โมเดลการปรับใช้แบบดึง (pull deployment model) โดยที่โหนดเอเจนต์จะตรวจสอบสถานะเป็นประจำ — หลังจากทุกๆ 1800 ใช้เวลาไม่กี่วินาที — เพื่อตรวจสอบว่าโหนดหลักจำเป็นต้องอัปเดตอะไรบนเอเจนต์หรือไม่ หากจำเป็นต้องอัปเดต เอเจนต์จะดึงโค้ด Puppet ที่จำเป็นจากโหนดหลักและดำเนินการตามที่ต้องการ

เราจะอธิบายเรื่องนี้ด้วยตัวอย่างของการตั้งค่าแบบมาสเตอร์-เอเจนต์

ปริญญาโท

นี่คือเครื่องที่ใช้ระบบปฏิบัติการ Linux โดยติดตั้งซอฟต์แวร์ Puppet master ไว้ เครื่องนี้มีหน้าที่ดูแลรักษาการตั้งค่าต่างๆ ในรูปแบบของโค้ด Puppet โหนด master ต้องเป็นระบบปฏิบัติการ Linux เท่านั้น

ตัวแทน

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

สามารถตั้งค่าเอเจนต์บนระบบปฏิบัติการที่รองรับได้ทุกระบบ เช่น ลินุกซ์ Windows, Solarisหรือ Mac OS

การสื่อสารระหว่างอุปกรณ์หลักและอุปกรณ์รองนั้นเกิดขึ้นผ่านใบรับรองความปลอดภัย

การสื่อสารระหว่าง Master และ Agent

ขั้นตอน 1) เมื่อการเชื่อมต่อระหว่างเอเจนต์และมาสเตอร์เสร็จสมบูรณ์แล้ว เอเจนต์ Puppet จะส่งข้อมูลเกี่ยวกับสถานะของตนไปยังเซิร์ฟเวอร์มาสเตอร์ Puppet ข้อมูลเหล่านี้เรียกว่า Facts ซึ่งประกอบด้วยชื่อโฮสต์ รายละเอียดเคอร์เนล ที่อยู่ IP รายละเอียดชื่อไฟล์ และอื่นๆ

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

ขั้นตอน 3) เอเจนต์ใช้รายการการกำหนดค่านี้เพื่อใช้การเปลี่ยนแปลงการกำหนดค่าที่จำเป็นบนโหนด

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

ขั้นตอน 4) เมื่อดำเนินการเสร็จสิ้นแล้ว โหนดจะรายงานกลับไปยัง Puppet master เพื่อระบุว่าการกำหนดค่าได้รับการใช้งานและเสร็จสมบูรณ์แล้ว

บล็อกหุ่นเชิด

Puppet มอบความยืดหยุ่นในการผสานรวมรายงานกับเครื่องมือของบุคคลที่สามโดยใช้ Puppet API

ตัวต่อหุ่นกระบอกมี 4 ประเภท ได้แก่:

1. แหล่งข้อมูล
2. เรียน
3. ประจักษ์
4. โมดูล

ทรัพยากรหุ่นเชิด

ทรัพยากรของ Puppet คือส่วนประกอบพื้นฐานของ Puppet

ทรัพยากรคือ ฟังก์ชั่นที่ฝังไว้ ซึ่งทำงานอยู่เบื้องหลังเพื่อดำเนินการตามที่ต้องการใน Puppet

ชั้นเรียนหุ่นกระบอก

ทรัพยากรที่แตกต่างกันหลายอย่างสามารถจัดกลุ่มเข้าด้วยกันเป็นหน่วยเดียวที่เรียกว่า คลาส ได้

การแสดงหุ่นเชิด

ไฟล์ Manifest คือไดเร็กทอรีที่บรรจุไฟล์ Puppet DSL ไฟล์เหล่านี้มีนามสกุล .pp ซึ่งย่อมาจาก Puppet program โค้ดของ Puppet ประกอบด้วยคำจำกัดความหรือการประกาศคลาสของ Puppet

โมดูลหุ่นเชิด

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

ยกตัวอย่างเช่น MySQL โมดูลติดตั้งและกำหนดค่า MySQLและ Jenkins โมดูลจัดการ Jenkins.

ประเภทของทรัพยากรหุ่นเชิด

โดยทั่วไป ระบบประกอบด้วยไฟล์ ผู้ใช้ บริการ กระบวนการ แพ็กเกจ และอื่นๆ ใน Puppet สิ่งเหล่านี้เรียกว่าทรัพยากร และเป็นส่วนประกอบพื้นฐานของ Puppet

การดำเนินการทั้งหมดบนเอเจนต์ Puppet นั้นดำเนินการโดยใช้ทรัพยากรของ Puppet

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

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

ประเภททรัพยากรมีสามประเภท:

1. แกนหุ่นเชิดหรือประเภททรัพยากรในตัว
2. ประเภททรัพยากรที่กำหนดโดยหุ่นเชิด
3. ประเภททรัพยากรที่กำหนดเองสำหรับหุ่นเชิด

แกนหุ่นเชิดหรือประเภททรัพยากรในตัว

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

ประเภททรัพยากรที่กำหนดโดยหุ่นเชิด

ประเภททรัพยากรที่กำหนดไว้ (Defined resource types) คือประเภททรัพยากรที่มีน้ำหนักเบา ซึ่งเขียนขึ้นในภาษาประกาศของ Puppet โดยใช้การผสมผสานของประเภททรัพยากรที่มีอยู่เดิม

ประเภททรัพยากรที่กำหนดเองสำหรับหุ่นเชิด

ประเภททรัพยากรที่กำหนดเองคือประเภททรัพยากรที่กำหนดเองอย่างสมบูรณ์ซึ่งเขียนด้วยภาษา Ruby

เรามาสำรวจประเภททรัพยากรของ Puppet ให้ละเอียดยิ่งขึ้นกันเถอะ

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

Puppet --help

ในกรณีของเรา เราสนใจคำสั่งย่อย “ทรัพยากรซึ่งเราจะใช้ในการค้นหาข้อมูลเกี่ยวกับประเภททรัพยากรในตัวของ Puppet

ในเทอร์มินัล พิมพ์คำสั่งใดๆ ต่อไปนี้เพื่อแสดงรายการ การปฏิบัติ เกี่ยวข้องกับคำสั่งย่อย Puppet “ทรัพยากร"

Puppet help resource		
Puppet resource --help		

ในกรณีนี้เรามี ทรัพยากร ในฐานะหน่วยย่อยและ –ประเภท ในฐานะการกระทำ

Puppet มีทรัพยากรหลักในตัว 49 ประเภท

ในเทอร์มินัล ให้พิมพ์คำสั่งต่อไปนี้เพื่อแสดงรายการประเภททรัพยากร Puppet ที่มีอยู่ภายในระบบ:

puppet resource –types

แต่ละประเภทรองรับรายการของ แอตทริบิวต์- คุณลักษณะเหล่านี้มีคำอธิบายโดยละเอียดที่ Puppet ใช้ในการจัดการทรัพยากร

หากต้องการดูคุณสมบัติทั้งหมดที่เกี่ยวข้องกับประเภททรัพยากรของ Puppet ให้ใช้คำสั่งต่อไปนี้:

puppet describe <resource type name>	

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

หุ่นอธิบายแพ็คเกจ

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

คลาสหุ่นกระบอกคืออะไร?

คลาสเรียนหุ่นกระบอก คือชุดรวมทรัพยากรเกี่ยวกับหุ่นกระบอกที่จัดไว้เป็นหน่วยเดียว

Puppet แนะนำคลาสเพื่อทำให้โครงสร้างสามารถนำมาใช้ซ้ำและจัดระเบียบได้

ขั้นแรก เราต้องกำหนดคลาสโดยใช้ไวยากรณ์การกำหนดคลาส คลาสต้องไม่ซ้ำกันและสามารถประกาศได้เพียงครั้งเดียวด้วยชื่อเดียวกัน:

class <class-name> {
<Resource declarations>
}

ตัวอย่าง:

class ntpconfig {
    file {
        "/etc/ntp.conf": 
     ensure=> "present", content=> "server 0.centos.pool.ntp.org iburst\n",
    }
}

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

ประกาศชั้นเรียน

หากต้องการใช้คลาสที่กำหนดไว้ในโค้ดของคุณ ให้ใช้ ประกอบด้วย คำสำคัญ.

class ntpconfig {
    file {
        "/etc/ntp.conf": 
      ensure=> "present", 
      content=> "server 0.centos.pool.ntp.org iburst\n",
    }
}
include ntpconfig

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

สาธิตการติดตั้ง NTP

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

rpm -qa | grep -i ntp

ดังที่เราเห็น แพ็กเกจ NTP มีอยู่แล้วบนเซิร์ฟเวอร์ เรามาลบแพ็กเกจ NTP ที่มีอยู่แล้วออกกัน:

yum remove ntp

หลังจากถอนการติดตั้งแพ็กเกจแล้ว โปรดตรวจสอบให้แน่ใจว่าไฟล์ ntp.conf ไม่มีอยู่แล้ว:

ls -lrt /etc/ntp.conf

ตรวจสอบว่าไม่มีบริการ ntp อยู่โดยการเรียกใช้คำสั่งต่อไปนี้:

systemctl status ntp

สร้างไฟล์ .pp ใหม่เพื่อบันทึกโค้ด จากบรรทัดคำสั่ง:

vi demontp.pp

เปลี่ยนเป็นโหมดแทรกโดยกดปุ่ม i บนแป้นพิมพ์

พิมพ์รหัสต่อไปนี้เพื่อสร้างไฟล์ใหม่:

# Class Definition 
class ntpconfig {
    # Installing NTP Package 
  package {"ntp": 
    ensure=> "present",
    }
    # Configuring NTP configuration file 
  file {"/etc/ntp.conf": 
    ensure=> "present", 
    content=> "server 0.centos.pool.ntp.org iburst\n",
    }
    # Starting NTP services 
  service {"ntpd": 
    ensure=> "running",
    }
}

หลังจากแก้ไขเสร็จแล้ว ให้กดปุ่ม esc

หากต้องการบันทึกไฟล์ ให้กด :wq!

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

puppet parser validate demontp.pp

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

su root

เอกสาร เป็นขั้นตอนถัดไปในกระบวนการสร้างโค้ด ให้ดำเนินการคำสั่งต่อไปนี้เพื่อทดสอบแบบ Smoke Test:

Puppet applies demontp.pp --noop

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

puppet apply demontp.pp

Puppet ไม่ได้แสดงอะไรเลยเพราะคลาสสาธิตเพิ่งเริ่มต้น กำหนด แต่ไม่ ประกาศ.

ดังนั้น จนกว่าคุณจะประกาศคลาส Puppet โค้ดจึงจะยังไม่ถูกนำไปใช้

ขอให้เรา ประกาศ คลาสสาธิตภายในโค้ดเดียวกันโดยใช้ รวมถึงชื่อชั้นเรียน ในตอนท้ายของรหัส:

# Class Definition 
class ntpconfig {
    # Installing NTP Package 
  package {"ntp": 
    ensure=> "present",
    }
    # Configuring NTP configuration file 
  file {"/etc/ntp.conf": 
    ensure=> "present", 
    content=> "server 0.centos.pool.ntp.org iburst\n",
    }
    # Starting NTP services 
  service {"ntpd": 
    ensure=> "running",
    }
}

# Class Declaration 
include ntpconfig

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

puppet parser validate demontp.pp

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

su root

การทดสอบ เป็นขั้นตอนถัดไปในกระบวนการสร้างโค้ด ให้ดำเนินการคำสั่งต่อไปนี้เพื่อทดสอบแบบ Smoke Test:

Puppet apply demontp.pp --noop

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

puppet apply demontp.pp

คราวนี้โค้ดจะถูกนำไปใช้เนื่องจากคลาสได้รับการกำหนดและประกาศไว้แล้ว

ตรวจสอบให้แน่ใจว่าไฟล์ ntp.conf มีอยู่แล้ว:

ls -lrt /etc/ntp.conf

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

systemctl status ntpd

คำถามที่พบบ่อย