การสอนหุ่นกระบอกสำหรับผู้เริ่มต้น: หุ่นกระบอกคืออะไรและใช้อย่างไร?

ก่อนที่เราจะเรียน Puppet มาทำความเข้าใจก่อน:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

ก่อนที่เราจะเรียนรู้ Puppet DSL มาทำความเข้าใจกระบวนทัศน์การเขียนโปรแกรมกันก่อน:

กระบวนทัศน์การเขียนโปรแกรมเป็นรูปแบบที่คุณใช้ในการเขียนโปรแกรมคอมพิวเตอร์

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

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

เราจะมุ่งเน้นไปที่ความจำเป็นและการประกาศ

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

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

ตัวอย่าง:

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

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

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

ตัวอย่าง:

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

ตัวอย่าง	สิ่งที่ต้องทำ	วิธีการทำ
ความจำเป็น	ใช่	ใช่
ประกาศ	ใช่	ไม่

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

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

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

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

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

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

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

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

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

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

รูปแบบการใช้งานแบบดึงตาม

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

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

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

ลองอธิบายด้วยตัวอย่าง:

ตัวอย่าง: หลัก – การตั้งค่าตัวแทน:

ปริญญาโท

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

ตัวแทน

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

สามารถกำหนดค่าตัวแทนบนระบบปฏิบัติการที่รองรับ เช่น Linux หรือ Windows or Solaris หรือแมคโอเอส

การสื่อสารระหว่างหลักและตัวแทนถูกสร้างขึ้นผ่านใบรับรองที่ปลอดภัย

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

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

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

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

ในกรณีที่ไม่มีการเบี่ยงเบนในการกำหนดค่า Agent จะไม่ทำการเปลี่ยนแปลงการกำหนดค่าใดๆ และปล่อยให้โหนดทำงานด้วยการกำหนดค่าเดียวกัน

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

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

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

โครงสร้างหุ่นกระบอกมี 4 ประเภท ได้แก่

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

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

ทรัพยากรหุ่นเชิดเป็นส่วนสำคัญของหุ่นเชิด

ทรัพยากรคือ ฟังก์ชั่นที่ฝังไว้ ที่ทำงานอยู่ที่แบ็กเอนด์เพื่อดำเนินการที่จำเป็นในหุ่นเชิด

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

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

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

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

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

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

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

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

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

หุ่นเชิด การดำเนินการทั้งหมดบนตัวแทนหุ่นเชิดจะดำเนินการด้วยความช่วยเหลือจากทรัพยากรหุ่นเชิด

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

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

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

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

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

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

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

ประเภททรัพยากรที่กำหนดคือประเภททรัพยากรขนาดเล็กที่เขียนด้วยภาษาประกาศ Puppet โดยใช้การผสมผสานระหว่างประเภททรัพยากรที่มีอยู่

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

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

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

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

Puppet --help

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

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

Puppet help resource		
Puppet resource --help		

ในกรณีนี้เรามี ทรัพยากร เป็นคำสั่งย่อยและ –ประเภท เป็นการกระทำ

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

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

puppet resource –types

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

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

puppet describe <resource type name>	

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

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

เป็นเรื่องยากสำหรับมือใหม่ที่จะเข้าใจและเชื่อมโยงไฟล์รหัสหุ่นเชิดที่ไม่ได้รับการจัดการจำนวนมาก เราจึงต้องมีการจัดกลุ่มเพื่อเชื่อมโยงการทำงานต่างๆ เข้าด้วยกัน เป้าหมายคือการแก้ปัญหาเดียว เช่น การทำงานทั้งหมดที่จำเป็นในการกำหนดค่า 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 ไม่มีอยู่บนเซิร์ฟเวอร์อยู่แล้ว คำสั่งต่อไปนี้จะไม่ส่งคืนสิ่งใดเลยหากไม่มี telnet บนเซิร์ฟเวอร์:

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

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

puppet apply demontp.pp

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

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

puppet apply demontp.pp

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

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

ls -lrt /etc/ntp.conf

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

systemctl status ntpd