เชฟ - คู่มือฉบับย่อ

Chef เป็นเทคโนโลยีโอเพ่นซอร์สที่พัฒนาโดย Opscode Adam Jacob ผู้ร่วมก่อตั้ง Opscode เป็นที่รู้จักในฐานะผู้ก่อตั้ง Chef เทคโนโลยีนี้ใช้การเข้ารหัส Ruby เพื่อพัฒนาส่วนประกอบพื้นฐานเช่นสูตรอาหารและตำราอาหาร Chef ใช้ในโครงสร้างพื้นฐานอัตโนมัติและช่วยในการลดงานที่ต้องทำเองและซ้ำ ๆ สำหรับการจัดการโครงสร้างพื้นฐาน

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

ทำไมต้องเป็นเชฟ

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

ใน DevOps เราใช้ Chef เพื่อปรับใช้และจัดการเซิร์ฟเวอร์และแอปพลิเคชันภายในองค์กรและบนคลาวด์

คุณสมบัติของเชฟ

ต่อไปนี้เป็นคุณสมบัติที่โดดเด่นที่สุดของเชฟ -

  • Chef ใช้ภาษา Ruby ที่เป็นที่นิยมเพื่อสร้างภาษาเฉพาะโดเมน

  • เชฟไม่ได้ตั้งสมมติฐานเกี่ยวกับสถานะปัจจุบันของโหนด ใช้กลไกเพื่อรับสถานะปัจจุบันของเครื่อง

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

ข้อดีของเชฟ

เชฟเสนอข้อดีดังต่อไปนี้ -

  • Lower barrier for entry - เนื่องจาก Chef ใช้ภาษา Ruby ดั้งเดิมในการกำหนดค่าภาษาการกำหนดค่ามาตรฐานจึงสามารถหยิบขึ้นมาได้โดยทุกคนที่มีประสบการณ์ในการพัฒนา

  • Excellent integration with cloud- การใช้ยูทิลิตี้มีดสามารถรวมเข้ากับเทคโนโลยีคลาวด์ใด ๆ ได้อย่างง่ายดาย เป็นเครื่องมือที่ดีที่สุดสำหรับองค์กรที่ต้องการกระจายโครงสร้างพื้นฐานบนสภาพแวดล้อมแบบมัลติคลาวด์

ข้อเสียของเชฟ

ข้อเสียที่สำคัญบางประการของ Chef มีดังนี้ -

  • ข้อเสียอย่างหนึ่งของ Chef คือวิธีควบคุมตำราอาหาร ต้องเลี้ยงลูกอย่างต่อเนื่องเพื่อไม่ให้คนที่ทำงานยุ่งวุ่นวายกับตำราอาหารของคนอื่น

  • มีเพียง Chef Solo เท่านั้น

  • ในสถานการณ์ปัจจุบันเหมาะสำหรับ AWS Cloud เท่านั้น

  • ไม่ใช่เรื่องง่ายที่จะเรียนรู้หากบุคคลนั้นไม่คุ้นเคยกับ Ruby

  • เอกสารประกอบยังขาด

องค์ประกอบสำคัญของเชฟ

สูตรอาหาร

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

หนังสือสอนทำอาหาร

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

ทรัพยากร

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

  • package - จัดการแพ็คเกจบนโหนด

  • service - จัดการบริการบนโหนด

  • user - จัดการผู้ใช้บนโหนด

  • group - จัดการกลุ่ม

  • template - จัดการไฟล์ด้วยเทมเพลต Ruby ที่ฝังอยู่

  • cookbook_file - ถ่ายโอนไฟล์จากไดเร็กทอรีย่อยของไฟล์ในตำราอาหารไปยังตำแหน่งบนโหนด

  • file - จัดการเนื้อหาของไฟล์บนโหนด

  • directory - จัดการไดเรกทอรีบนโหนด

  • execute - ดำเนินการคำสั่งบนโหนด

  • cron - แก้ไขไฟล์ cron ที่มีอยู่บนโหนด

แอตทริบิวต์

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

ไฟล์

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

เทมเพลต

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

Metadata.rb

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

โครงสร้างตำราอาหารเริ่มต้น

C:\chef\cookbooks\nginx>tree 
Folder PATH listing for volume Local Disk 
Volume serial number is BE8B-6427 
C: ├───attributes 
├───definitions 
├───files 
│   └───default 
├───libraries 
├───providers 
├───recipes 
├───resources 
└───templates 
    └───default

เชฟ - เทคโนโลยีที่เกี่ยวข้อง

ต่อไปนี้เป็นรายการเทคโนโลยีที่เกี่ยวข้องกับเชฟ

หุ่น

Puppet เป็นวิธีมาตรฐานในการส่งมอบและใช้งานซอฟต์แวร์ไม่ว่าจะทำงานที่ใด เป็นเอ็นจิ้นการดูแลระบบอัตโนมัติสำหรับระบบ Linux, Unix และ Windows ที่ทำงานด้านการดูแลระบบตามข้อกำหนดแบบรวมศูนย์

หลัก features of Puppet มีดังนี้ -

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

ตอบได้

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

หลัก features of Ansible มีดังนี้ -

  • ง่ายและสะดวกในการเรียนรู้
  • เขียนด้วยภาษา Python
  • Agentless
  • Playbooks ที่ใช้ YAML
  • กาแล็กซี่ Ansible

SaltStack

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

ผ้า

Fabric เป็นภาษาโปรแกรมที่ใช้ Python ซึ่งได้รับการพัฒนาเป็น API ของ Python ซึ่งจำเป็นต้องนำเข้าในโค้ด Python เพื่อกำหนดค่าและจัดการโครงสร้างพื้นฐาน

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

เพื่อให้โครงสร้างพื้นฐานของ Chef ทำงานได้เราจำเป็นต้องตั้งค่าหลาย ๆ อย่างตามลำดับ

ในการตั้งค่าข้างต้นเรามีส่วนประกอบดังต่อไปนี้

เชฟเวิร์คสเตชั่น

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

เชฟเซิร์ฟเวอร์

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

เชฟโหนด

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

การใช้ระบบควบคุมเวอร์ชันเป็นส่วนพื้นฐานของระบบอัตโนมัติโครงสร้างพื้นฐาน มีระบบควบคุมเวอร์ชันหลายประเภทเช่น SVN, CVS และ GIT เนื่องจากความนิยมของ GIT ในชุมชน Chef เราจึงใช้การตั้งค่า GIT

Note - อย่าคิดว่าจะสร้างโครงสร้างพื้นฐานเป็นรหัสโดยไม่มีระบบควบคุมเวอร์ชัน

บน Windows

Step 1- ดาวน์โหลดตัวติดตั้ง Windows จากwww.git-scm.orgและทำตามขั้นตอนการติดตั้ง

Step 2 - ลงทะเบียนเพื่อรับที่เก็บส่วนกลางบน GitHub

Step 3- อัปโหลดคีย์ ssh ไปยังบัญชี GitHub เพื่อให้สามารถโต้ตอบกับมันได้อย่างง่ายดาย สำหรับรายละเอียดเกี่ยวกับคีย์ ssh ไปที่ลิงค์ต่อไปนี้https://help.github.com/articles/generatingssh-keys.

Step 4 - สุดท้ายสร้าง repo ในบัญชี github โดยไปที่ https://github.com/new ด้วยชื่อของ chef-repo

ก่อนที่จะเริ่มเขียนตำราอาหารคุณสามารถตั้งค่าที่เก็บ GIT เริ่มต้นในกล่องการพัฒนาและโคลนที่เก็บว่างที่ Opscode ให้มา

Step 1 - ดาวน์โหลดโครงสร้างว่างที่เก็บ Opscode Chef

$ wget https://github.com/opscode/chef-repo/tarball/master

Step 2 - สกัดบอลน้ำมันดิน

$ tar –xvf master

Step 3 - เปลี่ยนชื่อไดเร็กทอรี

$ mv opscode-chef-repo-2c42c6a/ chef-repo

Step 4 - เปลี่ยนไดเร็กทอรีการทำงานปัจจุบันเป็นเชฟ repo

$ cd chef-repo

Step 5 - เริ่มต้นรับ repo ใหม่

$ git init.

Step 6 - เชื่อมต่อกับ repo ของคุณบน git hub

$ git remote add origin [email protected]:vipin022/chef-

Step 7 - กด repo ในเครื่องไปที่ github

$ git add. $ git commit –m “empty repo structure added” 
$ git push –u origin maste

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

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

Opscode จัดเตรียมเวอร์ชันแพ็กเกจอย่างสมบูรณ์ซึ่งไม่มีข้อกำหนดเบื้องต้นภายนอกใด ๆ เชฟที่บรรจุเต็มนี้เรียกว่าomnibus installer.

บนเครื่อง Windows

Step 1 - ดาวน์โหลดไฟล์ setup. msi ของ chefDK บนเครื่อง

Step 2 - ทำตามขั้นตอนการติดตั้งและติดตั้งในตำแหน่งเป้าหมาย

การตั้งค่าจะมีลักษณะดังที่แสดงในภาพหน้าจอต่อไปนี้

ตัวแปรเส้นทาง ChefDK

$ echo $PATH 
/c/opscode/chef/bin:/c/opscode/chefdk/bin:

บนเครื่อง Linux

ในการตั้งค่าบนเครื่อง Linux เราต้องทำการ curl บนเครื่องก่อน

Step 1 - เมื่อติดตั้ง curl บนเครื่องแล้วเราจำเป็นต้องติดตั้ง Chef บนเวิร์กสเตชันโดยใช้โปรแกรมติดตั้ง Omnibus Chef ของ Opscode

$ curl –L https://www.opscode.com/chef/install.sh | sudo bash

Step 2 - ติดตั้ง Ruby บนเครื่อง

Step 3 - เพิ่ม Ruby ให้กับตัวแปรเส้นทาง

$ echo ‘export PATH = ”/opt/chef/embedded/bin:$PATH”’ ≫ ~/.bash_profile && 
source ~/.bash_profile

Omnibus Chef จะติดตั้ง Ruby และอัญมณี Ruby ที่จำเป็นทั้งหมดลงใน /opt/chef/embedded โดยการเพิ่ม /opt/chef/embedded/bin ไดเร็กทอรีไปยังไฟล์. bash_profile

หากมีการติดตั้ง Ruby ไว้แล้วให้ติดตั้งอัญมณี Chef Ruby บนเครื่องโดยเรียกใช้คำสั่งต่อไปนี้

$ gem install chef

ในการทำให้ Chef node สื่อสารกับเซิร์ฟเวอร์ Chef คุณต้องตั้งค่าไคลเอนต์ Chef บนโหนด

ลูกค้าเชฟ

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

ที่นี่เราจะใช้ Vagrant เพื่อจัดการ VM Vagrant ยังสามารถกำหนดค่าด้วยตัวจัดเตรียมเช่น Shell script, Chef และ Puppet เพื่อให้ VM เข้าสู่สถานะที่ต้องการ ในกรณีของเราเราจะใช้ Vagrant เพื่อจัดการ VM โดยใช้ VirtualBox และ Chef client เป็นตัวจัดเตรียม

Step 1 - ดาวน์โหลดและติดตั้ง VirtualBox จาก https://www.virtualbox.org/wiki/downlod

Step 2 - ดาวน์โหลดและติดตั้ง Vagrant ได้ที่ http://downloads.vagrantup.com

Step 3 - ติดตั้งปลั๊กอิน Vagrant Omnibus เพื่อให้ Vagrant ติดตั้งไคลเอนต์ Chef บน VM

$ vagrant plugin install vagrant-omnibus

การสร้างและบูตเครื่องเสมือน

Step 1- เราสามารถดาวน์โหลดกล่อง Vagrant ที่ต้องการได้จาก repo Opscode vagrant ดาวน์โหลดกล่อง opscode-ubuntu-12.04 จาก URL ต่อไปนี้https://opscode-vmbento.s3.amazonaws.com/vagrant/opscode_ubuntu-12.04_provisionerless.box

Step 2 - เมื่อคุณมีไฟล์ Vagrant แล้วให้ดาวน์โหลดเส้นทางที่คุณต้องการเพื่อแก้ไขไฟล์ Vagrant

vipin@laptop:~/chef-repo $ subl Vagrantfile 
Vagrant.configure("2") do |config| 
   config.vm.box = "opscode-ubuntu-12.04" 
   config.vm.box_url = https://opscode-vm-bento.s3.amazonaws.com/ 
   vagrant/opscode_ubuntu-12.04_provisionerless.box 
   config.omnibus.chef_version = :latest  
   config.vm.provision :chef_client do |chef| 
      chef.provisioning_path = "/etc/chef" 
      chef.chef_server_url = "https://api.opscode.com/ 
      organizations/<YOUR_ORG>" 
      chef.validation_key_path = "/.chef/<YOUR_ORG>-validator.pem"
      chef.validation_client_name = "<YOUR_ORG>-validator" 
      chef.node_name = "server" 
   end 
end

ในโปรแกรมข้างต้นคุณต้องอัปเดตชื่อ <YOUR_ORG> ด้วยชื่อองค์กรที่ถูกต้องหรือจำเป็น

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

$ vagrant up

Step 4 - เมื่อเครื่องขึ้นคุณสามารถล็อกอินเข้าเครื่องโดยใช้คำสั่งต่อไปนี้

$ vagrant ssh

ในคำสั่งด้านบน vagrantfile เขียนด้วย Ruby Domain Specific Language (DSL) สำหรับกำหนดค่าเครื่องเสมือนคนจรจัด

ในไฟล์ vagrant เรามีวัตถุ config Vagrant จะใช้ออบเจ็กต์ config นี้เพื่อกำหนดค่า VM

Vagrant.configure("2") do |config| 
……. 
End

ภายในบล็อกการกำหนดค่าคุณจะบอกคนจรจัดว่าจะใช้อิมเมจ VM ใดเพื่อบูตโหนด

config.vm.box = "opscode-ubuntu-12.04" 
config.vm.box_url = https://opscode-vm-bento.s3.amazonaws.com/ 
   vagrant/opscode_ubuntu-12.04_provisionerless.box

ในขั้นตอนต่อไปคุณจะบอกให้ Vagrant ดาวน์โหลดปลั๊กอินของรถโดยสาร

config.omnibus.chef_version = :latest

หลังจากเลือกกล่อง VM เพื่อบูตให้กำหนดค่าวิธีการจัดเตรียมกล่องโดยใช้ Chef

config.vm.provision :chef_client do |chef| 
….. 
End

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

chef.provisioning_path = "/etc/chef"

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

ChefSpecเป็นสิ่งที่จำลองการวิ่งของเชฟเท่านั้น ทดสอบรองเท้าในครัวขึ้นโหนดจริงและเรียกใช้ Chef

Step 1 - ติดตั้งห้องครัวทดสอบอัญมณีทับทิมและทดสอบอัญมณีเร่ร่อนในครัวเพื่อให้ห้องครัวทดสอบใช้คนเร่ร่อนในการปั่นทดสอบ

$ gem install kitchen 
$ gem install kitchen-vagrant

Step 2- ตั้งค่าห้องครัวทดสอบ ซึ่งสามารถทำได้โดยการสร้าง.kitchen.yml ในไดเรกทอรีตำราอาหาร

driver_plugin: vagrant 
driver_config: 
   require_chef_omnibus: true 
platforms: 
   - name: ubuntu-12.04 
   driver_config: 
      box: opscode-ubuntu-12.04 
      box_url: https://opscode-vm.s3.amazonaws.com/vagrant/opscode_ 
      ubuntu-12.04_provisionerless.box 
suites: 
   - name: default 
run_list: 
   - recipe[minitest-handler] 
   - recipe[my_cookbook_test] 
attributes: { my_cookbook: { greeting: 'Ohai, Minitest!'} }

ในโค้ดด้านบนส่วนหนึ่งระบุว่าคนเร่ร่อนจำเป็นต้องหมุน VM และกำหนดว่าคุณต้องการให้รถโดยสารติดตั้ง Chef บนโหนดเป้าหมาย

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

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

ทดสอบขั้นตอนการทำงานของห้องครัว

ต่อไปนี้เป็นขั้นตอนที่เกี่ยวข้องในเวิร์กโฟลว์ Test Kitchen

การสร้างตำราอาหารโดยใช้เชฟ

ใช้รหัสต่อไปนี้เพื่อสร้างตำราอาหาร

$ chef generate cookbook motd_rhel 
Installing Cookbook Gems: 

Compiling Cookbooks... 
Recipe: code_generator::cookbook
   * directory[C:/chef/cookbooks/motd_rhel] action create
      - create new directory C:/chef/cookbooks/motd_rhel
   
   * template[C:/chef/cookbooks/motd_rhel/metadata.rb] action create_if_missing
      - create new file C:/chef/cookbooks/motd_rhel/metadata.rb
      - update content in file C:/chef/cookbooks/motd_rhel/metadata.rb from none to 
      d6fcc2 (diff output suppressed by config)
   
   * template[C:/chef/cookbooks/motd_rhel/README.md] action create_if_missing
      - create new file C:/chef/cookbooks/motd_rhel/README.md
      - update content in file C:/chef/cookbooks/motd_rhel/README.md from none to 50deab
         (diff output suppressed by config)
   
   * cookbook_file[C:/chef/cookbooks/motd_rhel/chefignore] action create
      - create new file C:/chef/cookbooks/motd_rhel/chefignore
      - update content in file C:/chef/cookbooks/motd_rhel/chefignore from none to 15fac5
         (diff output suppressed by config)
   
   * cookbook_file[C:/chef/cookbooks/motd_rhel/Berksfile] action create_if_missing
      - create new file C:/chef/cookbooks/motd_rhel/Berksfile
      - update content in file C:/chef/cookbooks/motd_rhel/Berksfile from none to 9f08dc
         (diff output suppressed by config)
   
   * template[C:/chef/cookbooks/motd_rhel/.kitchen.yml] action create_if_missing
      - create new file C:/chef/cookbooks/motd_rhel/.kitchen.yml
      - update content in file C:/chef/cookbooks/motd_rhel/.kitchen.yml
         from none to 49b92b (diff output suppressed by config)
   
   * directory[C:/chef/cookbooks/motd_rhel/test/integration/default/serverspec]
      action create 
      - create new directory 
         C:/chef/cookbooks/motd_rhel/test/integration/default/serverspec
   
   * directory[C:/chef/cookbooks/motd_rhel/test/integration/helpers/serverspec]
      action create 
      - create new directory 
         C:/chef/cookbooks/motd_rhel/test/integration/helpers/serverspec
   
   * cookbook_file
      [C:/chef/cookbooks/motd_rhel/test/integration/helpers/serverspec/spec_helper.rb]
      action create_if_missing
      - create new file 
         C:/chef/cookbooks/motd_rhel/test/integration/helpers/serverspec/spec_helper.rb
      - update content in file
         C:/chef/cookbooks/motd_rhel/test/integration/helpers/serverspec/spec_helper.rb
            from none to d85df4 (diff output suppressed by config)
   
   * template
      [C:/chef/cookbooks/motd_rhel/test/integration/default/serverspec/defaul t_spec.rb]
      action create_if_missing
      - create new file
         C:/chef/cookbooks/motd_rhel/test/integration/default/serverspec/default_spec.rb
      - update content in file
         C:/chef/cookbooks/motd_rhel/test/integration/default/serverspec/default_spec.rb
            from none to 3fbdbd (diff output suppressed by config)
   
   * directory[C:/chef/cookbooks/motd_rhel/spec/unit/recipes] action create
      - create new directory C:/chef/cookbooks/motd_rhel/spec/unit/recipes
   
   * cookbook_file
      [C:/chef/cookbooks/motd_rhel/spec/spec_helper.rb] action create_if_missing
      - create new file C:/chef/cookbooks/motd_rhel/spec/spec_helper.rb
      - update content in file
         C:/chef/cookbooks/motd_rhel/spec/spec_helper.rb from none to 587075
            (diff output suppressed by config)
   
   * template
      [C:/chef/cookbooks/motd_rhel/spec/unit/recipes/default_spec.rb]
      action create_if_missing
      - create new file C:/chef/cookbooks/motd_rhel/spec/unit/recipes/default_spec.rb
      - update content in file
         C:/chef/cookbooks/motd_rhel/spec/unit/recipes/default_spec.rb
            from none to ff3b17 (diff output suppressed by config)
   
   * directory[C:/chef/cookbooks/motd_rhel/recipes] action create
      - create new directory C:/chef/cookbooks/motd_rhel/recipes
   
   * template[C:/chef/cookbooks/motd_rhel/recipes/default.rb] action create_if_missing
      - create new file C:/chef/cookbooks/motd_rhel/recipes/default.rb
      - update content in file
         C:/chef/cookbooks/motd_rhel/recipes/default.rb from none to c4b029
            (diff output suppressed by config) 
   
   * execute[initialize-git] action run 
      - execute git init . 
   
   * cookbook_file[C:/chef/cookbooks/motd_rhel/.gitignore] action create
      - create new file C:/chef/cookbooks/motd_rhel/.gitignore
      - update content in file C:/chef/cookbooks/motd_rhel/.gitignore from none to 33d469
         (diff output suppressed by config)
   
   * execute[git-add-new-files] action run
      - execute git add .
   
   * execute[git-commit-new-files] action run 
      - execute git commit -m "Add generated cookbook content"

ต่อไปนี้เป็นโครงสร้างตำราอาหารที่สร้างขึ้นโดยเป็นผลลัพธ์ของโค้ดด้านบน

ทดสอบไฟล์การกำหนดค่าห้องครัว

.kitchen.yaml ไฟล์

driver: 
   name: vagrant 
provisioner: 
   name: chef_zero 
# verifier: 
# name: inspec 
# format: doc 
platforms: 
   - name: ubuntu-14.04 
suites: 
   - name: default 
   run_list: 
      - recipe[motd_rhel::default] 
   attributes:

Drivers - ระบุซอฟต์แวร์ที่ใช้จัดการเครื่อง

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

Platform - สิ่งนี้ระบุระบบปฏิบัติการเป้าหมาย

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

การรันคำสั่งตามลำดับ

รายการครัว

$ kitchen list 
Instance  Driver  Provisioner Verifier   Transport Last Action 
ubuntu-1404 Vagrant ChefZero   Busser       Ssh   <Not Created>

ครัวสร้าง

$ kitchen create
-----> Starting Kitchen (v1.4.2)
-----> Creating <default-centos-72>...
      Bringing machine 'default' up with 'virtualbox' provider...
      ==> default: Box 'opscode-centos-7.2' could not be found.
         Attempting to find and install...
      default: Box Provider: virtualbox
      default: Box Version: >= 0
      ==> default: Box file was not detected as metadata. Adding it directly...
         ==> default: Adding box 'opscode-centos-7.2' (v0) for provider: virtualbox
         default: Downloading:
            https://opscode-vmbento.s3.amazonaws.com/vagrant/virtualbox/
            opscode_centos-7.1_chefprovisionerless.box[...]
         Vagrant instance <default-centos-72> created.
         Finished creating <default-centos-72> (3m12.01s).
         -----> Kitchen is finished. (3m12.60s)

ครัวบรรจบ

$ kitchen converge 
-----> Converging <default-centos-72>...        
      Preparing files for transfer        
      Preparing dna.json        
      Resolving cookbook dependencies with Berkshelf 4.0.1...
      Removing non-cookbook files before transfer       
      Preparing validation.pem        
      Preparing client.rb 
-----> Chef Omnibus   installation detected (install only if missing)        
      Transferring files to <default-centos-72>       
      Starting Chef Client, version 12.6.0        
      resolving cookbooks for run list: ["motd_rhel::default"]
      Synchronizing Cookbooks: - motd_rhel (0.1.0)       
      Compiling Cookbooks...       Converging 1 resources        
      Recipe: motd_rhel::default        (up to date)         
      Running handlers:       Running handlers complete       
      Chef Client finished, 0/1 resources updated in 01 seconds        
      Finished converging <default-centos-72> (0m3.57s). 
      -----> Kitchen is finished. (0m4.55s)

การตั้งค่าการทดสอบ

การเข้าสู่ระบบห้องครัวใช้เพื่อทดสอบว่า VM การทดสอบได้รับการจัดเตรียมอย่างถูกต้อง

$ kitchen login 
Last login: Thu Jan 30 19:02:14 2017 from 10.0.2.2 
hostname:  default-centos-72 
fqdn:      default-centos-72 
memory:    244180kBcpu count: 1

สุดท้ายออก

$ exit 
Logout 
Connection to 127.0.0.1 closed.

กำลังทำลายการตั้งค่า

$ Kitchen destroy 
-----> Starting Kitchen (v1.4.2) 
-----> Destroying <default-centos-72>...       
   ==> default: Forcing shutdown of VM...        
   ==> default: Destroying VM and associated drives...        
   Vagrant instance <default-centos-72> destroyed.        
   Finished destroying <default-centos-72> (0m4.94s). 
-----> Kitchen is finished. (0m5.93s)

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

  • โหนดพ่อครัว
  • Cookbook
  • Recipe
  • Environments
  • ทรัพยากรระบบคลาวด์
  • การจัดสรรระบบคลาวด์
  • การติดตั้งบนไคลเอนต์ Chef บนโหนด Chef

Knife มีชุดคำสั่งเพื่อจัดการโครงสร้างพื้นฐานของ Chef

คำสั่ง Bootstrap

  • มีด bootstrap [SSH_USER @] FQDN (ตัวเลือก)

คำสั่งไคลเอ็นต์

  • ลูกค้ามีดจำนวนมากลบ REGEX (ตัวเลือก)
  • ลูกค้ามีดสร้าง CLIENTNAME (ตัวเลือก)
  • ลูกค้ามีดลบ CLIENT (ตัวเลือก)
  • ลูกค้ามีดแก้ไขไคลเอนต์ (ตัวเลือก)
  • การใช้งาน: C: / opscode / chef / bin / knife (ตัวเลือก)
  • คีย์ไคลเอนต์มีดลบไคลเอนต์ KEYNAME (ตัวเลือก)
  • มีดไคลเอนต์คีย์แก้ไขไคลเอนต์คีย์ (ตัวเลือก)
  • มีดไคลเอนต์รายการคีย์ไคลเอนต์ (ตัวเลือก)
  • มีดไคลเอ็นต์คีย์แสดงไคลเอ็นต์ KEYNAME (ตัวเลือก)
  • รายชื่อลูกค้ามีด (ตัวเลือก)
  • ลูกค้ามีดลงทะเบียนลูกค้าใหม่ (ตัวเลือก)
  • ลูกค้ามีดแสดง CLIENT (ตัวเลือก)

กำหนดค่าคำสั่ง

  • มีดกำหนดค่า (ตัวเลือก)
  • มีดกำหนดค่าไคลเอ็นต์ DIRECTORY

คำสั่งตำราอาหาร

  • มีดตำราลบ REGEX จำนวนมาก (ตัวเลือก)
  • ตำรามีดสร้าง COOKBOOK (ตัวเลือก)
  • มีดตำราลบ COOKBOOK VERSION (ตัวเลือก)
  • ดาวน์โหลดตำรามีด COOKBOOK [VERSION] (ตัวเลือก)
  • รายการตำรามีด (ตัวเลือก)
  • มีดตำราอาหารเมตาดาต้า COOKBOOK (ตัวเลือก)
  • ข้อมูลเมตาของมีดตำราอาหารจาก FILE (ตัวเลือก)
  • มีดตำราแสดง COOKBOOK [VERSION] [PART] [FILENAME] (ตัวเลือก)
  • แบบทดสอบตำรามีด [COOKBOOKS ... ] (ตัวเลือก)
  • อัปโหลดมีดตำรา [COOKBOOKS ... ] (ตัวเลือก)

คำสั่งเว็บไซต์ตำราอาหาร

  • ดาวน์โหลดไซต์ตำรามีด COOKBOOK [VERSION] (ตัวเลือก)
  • เว็บไซต์มีดตำราติดตั้ง COOKBOOK [VERSION] (ตัวเลือก)
  • รายการเว็บไซต์มีดตำรา (ตัวเลือก)
  • การค้นหาไซต์ตำรามีด QUERY (ตัวเลือก)
  • มีดตำราอาหารแบ่งปัน COOKBOOK [CATEGORY] (ตัวเลือก)
  • เว็บไซต์มีดตำราแสดง COOKBOOK [VERSION] (ตัวเลือก)
  • เว็บไซต์มีดตำราไม่แชร์ COOKBOOK

คำสั่งกระเป๋าข้อมูล

  • กระเป๋าข้อมูลมีดสร้าง BAG [ITEM] (ตัวเลือก)
  • ถุงข้อมูลมีดลบ BAG [ITEM] (ตัวเลือก)
  • มีด data bag แก้ไข BAG ITEM (ตัวเลือก)
  • ถุงข้อมูลมีดจากไฟล์ BAG FILE | FOLDER [FILE | FOLDER .. ] (ตัวเลือก)
  • รายการถุงข้อมูลมีด (ตัวเลือก)
  • กระเป๋าใส่มีดแสดง BAG [ITEM] (ตัวเลือก)

คำสั่งสิ่งแวดล้อม

  • สภาพแวดล้อมมีดเปรียบเทียบ [ENVIRONMENT .. ] (ตัวเลือก)
  • สภาพแวดล้อมของมีดสร้างสภาพแวดล้อม (ตัวเลือก)
  • สภาพแวดล้อมมีดลบ ENVIRONMENT (ตัวเลือก)
  • สภาพแวดล้อมมีดแก้ไขสภาพแวดล้อม (ตัวเลือก)
  • สภาพแวดล้อมมีดจากไฟล์ FILE [FILE .. ] (ตัวเลือก)
  • รายการสภาพแวดล้อมมีด (ตัวเลือก)
  • สภาพแวดล้อมของมีดแสดงสภาพแวดล้อม (ตัวเลือก)

คำสั่ง Exec

  • ผู้บริหารมีด [SCRIPT] (ตัวเลือก)

คำสั่งช่วยเหลือ

  • ความช่วยเหลือมีด [รายการ | หัวข้อ]

คำสั่งดัชนี

  • สร้างดัชนีมีด (ตัวเลือก)

คำสั่งโหนด

  • โหนดมีดจำนวนมากลบ REGEX (ตัวเลือก)
  • โหนดมีดสร้าง NODE (ตัวเลือก)
  • โหนดมีดลบ NODE (ตัวเลือก)
  • โหนดมีดแก้ไข NODE (ตัวเลือก)
  • สภาพแวดล้อมโหนดมีดตั้งค่า NODE ENVIRONMENT
  • โหนดมีดจากไฟล์ FILE (ตัวเลือก)
  • รายการโหนดมีด (ตัวเลือก)
  • โหนดมีด run_list เพิ่ม [NODE] [ENTRY [, ENTRY]] (ตัวเลือก)
  • โหนดมีด run_list ลบ [NODE] [ENTRY [, ENTRY]] (ตัวเลือก)
  • โหนดมีด run_list ตั้งค่า NODE ENTRIES (ตัวเลือก)
  • โหนดมีดแสดง NODE (ตัวเลือก)

คำสั่ง OSC

  • มีด osc_user สร้าง USER (ตัวเลือก)
  • มีด osc_user ลบ USER (ตัวเลือก)
  • มีด osc_user แก้ไข USER (ตัวเลือก)
  • มีด osc_user รายการ (ตัวเลือก)
  • มีด osc_user ลงทะเบียนใหม่ USER (ตัวเลือก)
  • มีด osc_user แสดง USER (ตัวเลือก)

คำสั่งตามเส้นทาง

  • มีดลบ [PATTERN1 ... PATTERNn]
  • มีด deps PATTERN1 [PATTERNn]
  • รูปแบบมีดแตกต่างกัน
  • มีดดาวน์โหลด PATTERNS
  • มีดแก้ไข [PATTERN1 ... PATTERNn]
  • รายการมีด [-dfR1p] [PATTERN1 ... PATTERNn]
  • การแสดงมีด [PATTERN1 ... PATTERNn]
  • มีดอัพโหลดรูปแบบ
  • xargs มีด [COMMAND]

คำสั่งดิบ

  • มีด REQUEST_PATH ดิบ

คำสั่งสูตร

  • รายการสูตรมีด [PATTERN]

คำสั่งบทบาท

  • มีดบทบาทลบ REGEX จำนวนมาก (ตัวเลือก)
  • บทบาทมีดสร้าง ROLE (ตัวเลือก)
  • มีดบทบาทลบ ROLE (ตัวเลือก)
  • บทบาทมีดแก้ไข ROLE (ตัวเลือก)
  • บทบาทมีด env_run_list เพิ่ม [ROLE] [ENVIRONMENT] [ENTRY [, ENTRY]] (ตัวเลือก)
  • บทบาทมีด env_run_list ชัดเจน [ROLE] [ENVIRONMENT]
  • บทบาทมีด env_run_list ลบ [ROLE] [ENVIRONMENT] [ENTRIES]
  • บทบาทมีด env_run_list แทนที่ [ROLE] [ENVIRONMENT] [OLD_ENTRY] [NEW_ENTRY]
  • ชุดมีด env_run_list [ROLE] [ENVIRONMENT] [ENTRIES]
  • บทบาทมีดจากไฟล์ FILE [FILE .. ] (ตัวเลือก)
  • รายการบทบาทมีด (ตัวเลือก)
  • มีดบทบาท run_list เพิ่ม [ROLE] [ENTRY [, ENTRY]] (ตัวเลือก)
  • มีด run_list ล้าง [ROLE]
  • มีดบทบาท run_list ลบ [ROLE] [ENTRY]
  • บทบาทมีด run_list แทนที่ [ROLE] [OLD_ENTRY] [NEW_ENTRY]
  • ชุดมีด run_list [ROLE] [ENTRIES]
  • แสดงบทบาทมีด ROLE (ตัวเลือก)

ทำหน้าที่คำสั่ง

  • มีดเสิร์ฟ (ตัวเลือก)

คำสั่ง SSH

  • มีด ssh QUERY COMMAND (ตัวเลือก)

คำสั่ง SSL

  • ตรวจสอบ ssl มีด [URL] (ตัวเลือก)
  • มีด ssl ดึง [URL] (ตัวเลือก)

คำสั่งสถานะ

  • สถานะมีด QUERY (ตัวเลือก)

คำสั่งแท็ก

  • แท็กมีดสร้าง NODE TAG ...
  • มีดแท็กลบ NODE TAG ...
  • รายการแท็กมีด NODE

คำสั่งของผู้ใช้

  • ผู้ใช้มีดสร้าง USERNAME DISPLAY_NAME FIRST_NAME LAST_NAME EMAIL PASSWORD (ตัวเลือก)
  • ผู้ใช้มีดลบ USER (ตัวเลือก)
  • ผู้ใช้มีดแก้ไข USER (ตัวเลือก)
  • คีย์ผู้ใช้มีดสร้าง USER (ตัวเลือก)
  • คีย์ผู้ใช้มีดลบ USER KEYNAME (ตัวเลือก)
  • คีย์ผู้ใช้มีดแก้ไข USER KEYNAME (ตัวเลือก)
  • รายการคีย์ผู้ใช้มีด USER (ตัวเลือก)
  • คีย์ผู้ใช้มีดแสดง USER KEYNAME (ตัวเลือก)
  • รายชื่อผู้ใช้มีด (ตัวเลือก)
  • ผู้ใช้มีดลงทะเบียนใหม่ USER (ตัวเลือก)
  • ผู้ใช้มีดแสดง USER (ตัวเลือก)

การตั้งค่ามีด

ในการตั้งมีดต้องย้ายไปที่ .chef ไดเร็กทอรีและสร้างไฟล์ knife.rbภายใน repo เชฟซึ่งบอกมีดเกี่ยวกับรายละเอียดการกำหนดค่า ซึ่งจะมีรายละเอียดสองสามอย่าง

current_dir = File.dirname(__FILE__) 
log_level                :info 
log_location             STDOUT 
node_name                'node_name' 
client_key               "#{current_dir}/USER.pem" 
validation_client_name   'ORG_NAME-validator' 
validation_key           "#{current_dir}/ORGANIZATION-validator.pem" 
chef_server_url          'https://api.chef.io/organizations/ORG_NAME' 
cache_type               'BasicFile' 
cache_options( :path =>  "#{ENV['HOME']}/.chef/checksums" ) 
cookbook_path            ["#{current_dir}/../cookbooks"]

ในโค้ดด้านบนเราใช้เซิร์ฟเวอร์ Chef ที่โฮสต์ซึ่งใช้สองคีย์ต่อไปนี้

validation_client_name   'ORG_NAME-validator' 
validation_key           "#{current_dir}/ORGANIZATION-validator.pem"

ที่นี่ knife.rb จะบอกมีดว่าจะใช้องค์กรใดและจะหาคีย์ส่วนตัวได้ที่ไหน มันบอกมีดว่าจะหาคีย์ส่วนตัวของผู้ใช้ได้ที่ไหน

client_key               "#{current_dir}/USER.pem"

โค้ดบรรทัดต่อไปนี้บอกมีดว่าเรากำลังใช้เซิร์ฟเวอร์ที่โฮสต์

chef_server_url        'https://api.chef.io/organizations/ORG_NAME'

การใช้ไฟล์ knife.rb ตอนนี้มีด validator สามารถเชื่อมต่อกับ Opscode ที่โฮสต์ไว้ในองค์กรของคุณได้

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

ก่อนที่จะเรียกใช้ Chef-Solo บนเครื่องโลคัลคุณต้องติดตั้งสองไฟล์ต่อไปนี้บนเครื่องท้องถิ่น

  • Solo.rb - ไฟล์นี้จะบอก Chef เกี่ยวกับตำแหน่งที่จะหาตำราอาหารบทบาทและถุงข้อมูล

  • Node.json - ไฟล์นี้ตั้งค่ารายการเรียกใช้และแอตทริบิวต์เฉพาะโหนดหากจำเป็น

การกำหนดค่า solo.rb

ต่อไปนี้เป็นขั้นตอนในการกำหนดค่า solo.rb

Step 1 - สร้างไฟล์ solo.rb ภายใน repo chef

current_dir       = File.expand_path(File.dirname(__FILE__)) 
file_cache_path   "#{current_dir}" 
cookbook_path     "#{current_dir}/cookbooks" 
role_path         "#{current_dir}/roles" 
data_bag_path     "#{current_dir}/data_bags"

Step 2 - เพิ่มไฟล์ใน git repo

$ git add solo.rb

Step 3 - สร้างไฟล์ node.json ภายใน repo chef ด้วยเนื้อหาต่อไปนี้

{ 
   "run_list": [ "recipe[ntp]" ] 
}

Step 4 - รับตำรา ntp ใน repo เชฟโดยใช้มีด

vipin@laptop:~/chef-repo $ knife cookbook site install ntp 
Installing ntp to /Users/mma/work/chef-repo/cookbooks 
…TRUNCATED OUTPUT… 
Cookbook ntp version 1.3.0 successfully installed

Step 5 - เพิ่มไฟล์ node.json ใน Git

$ git add node.json

Step 6 - ยอมรับและพุชไฟล์เพื่อคอมไพล์ repo

vipin@laptop:~/chef-repo $ git commit -m "initial setup for Chef Solo" 
vipin@laptop:~/chef-repo $ git push 
Counting objects: 4, done. 
Delta compression using up to 4 threads. 
...TRUNCATED OUTPUT... 
To [email protected]:mmarschall/chef-repo.git 
b930647..5bcfab6 master -> master

เรียกใช้ตำราอาหารบนโหนด

Step 1 - เข้าสู่โหนดที่ต้องการจัดเตรียม Chef-Solo

Step 2 - โคลน repo เชฟบนเครื่อง

$ git clone $URL_PATH

Step 3 - cd ถึง repo เชฟ

$ cd chef-repo

สุดท้ายเรียกใช้ Chef-Solo เพื่อรวมโหนด -

$ sudo chef-solo -c solo.rb -j node.json 
[2017-20-08T22:54:13+01:00] INFO: *** Chef 11.0.0 *** 
[2017-20-08T22:54:13+01:00] INFO: Setting the run_list to 
["recipe[ntp]"] from JSON 
...TRUNCATED OUTPUT... 
[2012-12-08T22:54:16+01:00] INFO: Chef Run complete in 2.388374 
seconds 
[2012-12-08T22:54:16+01:00] INFO: Running report handlers

solo.rb กำหนดค่า Chef-Solo เพื่อค้นหาตำราอาหารบทบาทและถุงข้อมูลภายในไดเร็กทอรีปัจจุบัน: ที่เก็บ Chef

Chef-Soloรับการกำหนดค่าโหนดจากไฟล์ JSON ในตัวอย่างของเราเราเรียกมันว่า node.json หากคุณจะจัดการเซิร์ฟเวอร์หลายเครื่องคุณจะต้องมีไฟล์แยกกันสำหรับแต่ละโหนด จากนั้น Chef-Solo ก็ดำเนินการเรียกใช้ Chef ตามข้อมูลการกำหนดค่าที่พบใน solo.rb และ node.json

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

ส่วนประกอบสำคัญของตำราอาหาร

  • Recipes
  • Metadata
  • Attributes
  • Resources
  • Templates
  • Libraries
  • สิ่งอื่นใดที่ช่วยในการสร้างระบบ

การสร้างตำราอาหาร

มีสองวิธีในการสร้างตำราอาหารแบบไดนามิก

  • ใช้คำสั่งพ่อครัว
  • ใช้ยูทิลิตี้มีด

ใช้ Chef Command

ในการสร้างตำราอาหารเปล่าโดยใช้คำสั่ง Chef ให้เรียกใช้คำสั่งต่อไปนี้

C:\Users\vipinkumarm>chef generate cookbook <Cookbook Name> 
C:\Users\vipinkumarm>chef generate cookbook VTest
Installing Cookbook Gems:

Compiling Cookbooks...
Recipe: code_generator::cookbook
   * directory[C:/Users/vipinkumarm/VTest] action create
      - create new directory C:/Users/vipinkumarm/VTest
   
   * template[C:/Users/vipinkumarm/VTest/metadata.rb] action create_if_missing
      - create new file C:/Users/vipinkumarm/VTest/metadata.rb
      - update content in file C:/Users/vipinkumarm/VTest/metadata.rb 
         from none to 4b9435 (diff output suppressed by config)

   * template[C:/Users/vipinkumarm/VTest/README.md] action create_if_missing
      - create new file C:/Users/vipinkumarm/VTest/README.md
      - update content in file C:/Users/vipinkumarm/VTest/README.md 
         from none to 482077 (diff output suppressed by config)

   * cookbook_file[C:/Users/vipinkumarm/VTest/chefignore] action create
      - create new file C:/Users/vipinkumarm/VTest/chefignore
      - update content in file C:/Users/vipinkumarm/VTest/chefignore 
         from none to 15fac5 (diff output suppressed by config)
   
   * cookbook_file[C:/Users/vipinkumarm/VTest/Berksfile] action create_if_missing
      - create new file C:/Users/vipinkumarm/VTest/Berksfile
      - update content in file C:/Users/vipinkumarm/VTest/Berksfile 
         from none to 9f08dc (diff output suppressed by config)

   * template[C:/Users/vipinkumarm/VTest/.kitchen.yml] action create_if_missing
      - create new file C:/Users/vipinkumarm/VTest/.kitchen.yml
      - update content in file C:/Users/vipinkumarm/VTest/.kitchen.yml 
         from none to 93c5bd (diff output suppressed by config)

   * directory[C:/Users/vipinkumarm/VTest/test/integration/default/serverspec]
      action create
      - create new directory
         C:/Users/vipinkumarm/VTest/test/integration/default/serverspec
   
   * directory[C:/Users/vipinkumarm/VTest/test/integration/helpers/serverspec]
      action create
      - create new directory
         C:/Users/vipinkumarm/VTest/test/integration/helpers/serverspec
   
   * cookbook_file
      [C:/Users/vipinkumarm/VTest/test/integration/helpers/serverspec/sp ec_helper.rb]
      action create_if_missing
      - create new file
         C:/Users/vipinkumarm/VTest/test/integration/helpers/serverspec/spec_helper.rb
      - update content in file
         C:/Users/vipinkumarm/VTest/test/integration/helpers/serverspec/spec_helper.rb
         from none to d85df4 (diff output suppressed by config)
   
   * template
      [C:/Users/vipinkumarm/VTest/test/integration/default/serverspec/default _spec.rb]
      action create_if_missing
      - create new file
         C:/Users/vipinkumarm/VTest/test/integration/default/serverspec/default_spec.rb
      - update content in file
         C:/Users/vipinkumarm/VTest/test/integration/default/serverspec/default_spec.rb
         from none to 758b94 (diff output suppressed by config)
   
   * directory[C:/Users/vipinkumarm/VTest/spec/unit/recipes] action create
      - create new directory C:/Users/vipinkumarm/VTest/spec/unit/recipes
   
   * cookbook_file[C:/Users/vipinkumarm/VTest/spec/spec_helper.rb]
      action create_if_missing
      - create new file C:/Users/vipinkumarm/VTest/spec/spec_helper.rb
      - update content in file C:/Users/vipinkumarm/VTest/spec/spec_helper.rb
         from none to 587075 (diff output suppressed by config)

   * template[C:/Users/vipinkumarm/VTest/spec/unit/recipes/default_spec.rb]
      action create_if_missing
      - create new file C:/Users/vipinkumarm/VTest/spec/unit/recipes/default_spec.rb
      - update content in file 
         C:/Users/vipinkumarm/VTest/spec/unit/recipes/default_spec.rb
         from none to 779503 (diff output suppressed by config)
      - create new file C:/Users/vipinkumarm/VTest/recipes/default.rb
      - update content in file C:/Users/vipinkumarm/VTest/recipes/default.rb
         from none to 8cc381 (diff output suppressed by config)

   * cookbook_file[C:/Users/vipinkumarm/VTest/.gitignore] action create
      - create new file C:/Users/vipinkumarm/VTest/.gitignore
      - update content in file C:/Users/vipinkumarm/VTest/.gitignore from none to 33d469
         (diff output suppressed by config)

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

ใช้ Knife Utility

ใช้คำสั่งต่อไปนี้เพื่อสร้างตำราอาหารโดยใช้มีดยูทิลิตี้

C:\Users\vipinkumarm\VTest>knife cookbook create VTest2 
WARNING: No knife configuration file found 
** Creating cookbook VTest2 in C:/chef/cookbooks 
** Creating README for cookbook: VTest2 
** Creating CHANGELOG for cookbook: VTest2 
** Creating metadata for cookbook: VTest2

ต่อไปนี้จะเป็นโครงสร้างของตำราอาหาร

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

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

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

คุณสมบัติของไฟล์ metadata.rb

  • อยู่ที่ด้านบนสุดในโครงสร้างไดเรกทอรีตำราอาหาร

  • รวบรวมเมื่ออัปโหลดตำราอาหารไปยังเซิร์ฟเวอร์ Chef โดยใช้คำสั่งมีด

  • รวบรวมด้วยคำสั่งย่อย knife cookbook metadata

  • สร้างขึ้นโดยอัตโนมัติเมื่อรันคำสั่งสร้างมีด

การกำหนดค่า metadata.rb

ต่อไปนี้เป็นเนื้อหาเริ่มต้นของไฟล์ข้อมูลเมตา

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

สร้างบทบาท

vipin@laptop:~/chef-repo $ subl roles/web_servers.rb 
name "web_servers" 
description "This role contains nodes, which act as web servers" 
run_list "recipe[ntp]" 
default_attributes 'ntp' => { 
   'ntpdate' => { 
      'disable' => true 
   } 
}

เมื่อเราสร้างบทบาทได้แล้วเราจำเป็นต้องอัปโหลดไปยังเซิร์ฟเวอร์ Chef

อัปโหลดบทบาทไปยังเซิร์ฟเวอร์เชฟ

vipin@laptop:~/chef-repo $ knife role from file web_servers.rb

ตอนนี้เราต้องกำหนดบทบาทให้กับโหนดที่เรียกว่าเซิร์ฟเวอร์

กำหนดบทบาทให้กับโหนด

vipin@laptop:~/chef-repo $ knife node edit server 
"run_list": [ 
   "role[web_servers]" 
] 
Saving updated run_list on node server

เรียกใช้ Chef-Client

user@server:~$ sudo chef-client 
...TRUNCATED OUTPUT... 
[2013-07-25T13:28:24+00:00] INFO: Run List is [role[web_servers]] 
[2013-07-25T13:28:24+00:00] INFO: Run List expands to [ntp] 
...TRUNCATED OUTPUT...

มันทำงานอย่างไร

  • กำหนดบทบาทในไฟล์ Ruby ภายในโฟลเดอร์ role ของที่เก็บ Chef

  • บทบาทประกอบด้วยชื่อและแอตทริบิวต์คำอธิบาย

  • บทบาทประกอบด้วยรายการรันเฉพาะบทบาทและการตั้งค่าแอ็ตทริบิวต์เฉพาะบทบาท

  • ทุกโหนดที่มีบทบาทในรายการที่เรียกใช้จะมีรายการเรียกใช้ของบทบาทที่กำหนดไว้เป็นของตัวเอง

  • สูตรอาหารทั้งหมดในรายการเรียกใช้ของบทบาทจะดำเนินการบนโหนด

  • บทบาทจะถูกอัปโหลดไปยังเซิร์ฟเวอร์ Chef โดยใช้บทบาทมีดจากคำสั่งไฟล์

  • บทบาทจะถูกเพิ่มลงในรายการรันโหนด

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

Chef ช่วยในการกำหนดค่าสภาพแวดล้อมเฉพาะ เป็นความคิดที่ดีเสมอที่จะมีสภาพแวดล้อมแยกต่างหากสำหรับการพัฒนาการทดสอบและการผลิต

Chef เปิดใช้งานการจัดกลุ่มโหนดในสภาพแวดล้อมที่แยกจากกันเพื่อรองรับขั้นตอนการพัฒนาตามลำดับ

การสร้างสภาพแวดล้อม

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

vipin@laptop:~/chef-repo $ knife environment create book { 
   "name": "book", 
   "description": "", 
   "cookbook_versions": { 
   }, 
   "json_class": "Chef::Environment", 
   "chef_type": "environment", 
   "default_attributes": { 
   }, 
   "override_attributes": { 
   } 
} 
Created book

การทดสอบสภาพแวดล้อมที่สร้างขึ้น

vipin@laptop:~/chef-repo $ knife environment list 
_default 
book

แสดงรายการโหนดสำหรับทุกสภาพแวดล้อม

vipin@laptop:~/chef-repo $ knife node list 
my_server

_default สภาพแวดล้อม

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

แอตทริบิวต์สภาพแวดล้อม

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

แอตทริบิวต์สภาพแวดล้อมสามารถเป็นได้เฉพาะ default_attribute หรือ override_attribute ไม่สามารถเป็นแอตทริบิวต์ปกติ สามารถใช้ default_attribute หรือ override_attribute

ประเภทคุณสมบัติ

Default - แอตทริบิวต์เริ่มต้นจะถูกรีเซ็ตเสมอเมื่อเริ่มต้นไคลเอนต์ Chef ทุกรายที่รันและมีลำดับความสำคัญต่ำสุด

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

ลำดับการใช้แอตทริบิวต์

การรัน Chef-Client เป็น daemon ช่วยในการทราบสถานะของโหนดทั้งหมด ณ เวลาใดก็ได้ สิ่งนี้ช่วยในการเรียกใช้ Chef-Client ได้ตลอดเวลา

ข้อกำหนดเบื้องต้น

โหนดควรลงทะเบียนกับเซิร์ฟเวอร์ Chef และควรเรียกใช้ Chef-Client โดยไม่มีข้อผิดพลาดใด ๆ

Chef-Client ในโหมด Daemon

เริ่ม Chef-Client ในโหมด daemon รันทุกๆ 30 นาที

user@server:~$ sudo chef-client -i 1800

ในรหัสด้านบน - i เปิดใช้งานเพื่อรัน Chef-Client ในโหมด daemon บนโหนดที่ต้องการและ 1800 วินาทีกำหนดว่า Chef-Client daemon ควรรันในทุกๆ 30 นาที

กำลังตรวจสอบ Daemon Run

ตรวจสอบว่า Chef-Client กำลังรันเป็น daemon

user@server:~$ ps auxw | grep chef-client

คำสั่งดังกล่าวจะ grep กระบวนการ daemon ที่รันอยู่ของ Chef-Client

ทางอื่น

แทนที่จะเรียกใช้ Chef-Client เป็น daemon เราสามารถรันเช่นเดียวกับไฟล์ cron job.

user@server:~$ subl /etc/cron.d/chef_client 
PATH=/usr/local/bin:/usr/bin:/bin 
# m h dom mon dow user command 
*/15 * * * * root chef-client -l warn | grep -v 'retrying [1234]/5 in'

งาน cron ข้างต้นจะทำงานทุก ๆ 15 นาที

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

Chef มาพร้อมกับ Chef-Shell ซึ่งเป็นเซสชั่น Ruby แบบโต้ตอบกับ Chef ใน Chef-Shell เราสามารถสร้าง -

  • Attributes
  • เขียนสูตรอาหาร
  • การเริ่มต้นใช้งาน Chef

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

วิ่งเชลล์

Step 1 - เรียกใช้ Chef-Shell ในโหมดสแตนด์อโลน

mma@laptop:~/chef-repo $ chef-shell 
loading configuration: none (standalone chef-shell session) 
Session type: standalone 
Loading...[2017-01-12T20:48:01+01:00] INFO: Run List is [] 
[2017-01-12T20:48:01+01:00] INFO: Run List expands to [] 
done. 
This is chef-shell, the Chef Shell. 
Chef Version: 11.0.0 
http://www.opscode.com/chef 
http://wiki.opscode.com/display/chef/Home 
run `help' for help, `exit' or ^D to quit. 
Ohai2u mma@laptop!  
chef >

Step 2 - เปลี่ยนเป็นโหมดแอตทริบิวต์ใน Chef-Shell

  • chef > attributes_mode

Step 3 - การตั้งค่าแอตทริบิวต์

  • chef:attributes > set[:title] = "Chef Cookbook"

    • “ ตำราเชฟ”

  • chef:attributes > quit

    • :attributes

  • chef >

Step 4 - เปลี่ยนเป็นโหมดสูตรอาหาร

  • chef > recipe_mode

Step 5 - สร้างทรัพยากรไฟล์

chef:recipe > file "/tmp/book.txt" do 
chef:recipe > content node.title 
chef:recipe ?> end  

=> <file[/tmp/book.txt] @name: "/tmp/book.txt" @noop: nil @ 
before: nil @params: {} @provider: Chef::Provider::File @allowed_ 
actions: [:nothing, :create, :delete, :touch, :create_if_missing] 
@action: "create" @updated: false @updated_by_last_action: false 
@supports: {} @ignore_failure: false @retries: 0 @retry_delay: 
2 @source_line: "(irb#1):1:in `irb_binding'" @elapsed_time: 0 @ 
resource_name: :file @path: "/tmp/book.txt" @backup: 5 @diff: nil 
@cookbook_name: nil @recipe_name: nil @content: "Chef Cookbook">   

chef:recipe >

Step 6 - เริ่มต้น Chef ทำงานเพื่อสร้างไฟล์ที่มีเนื้อหาที่กำหนด

  • chef:recipe > run_chef

[2017-01-12T21:07:49+01:00] INFO: Processing file[/tmp/book.txt] 
action create ((irb#1) line 1) 
--- /var/folders/1r/_35fx24d0y5g08qs131c33nw0000gn/T/cheftempfile20121212- 
11348-dwp1zs 2012-12-12 21:07:49.000000000 
+0100 
+++ /var/folders/1r/_35fx24d0y5g08qs131c33nw0000gn/T/chefdiff20121212- 
11348-hdzcp1 2012-12-12 21:07:49.000000000 +0100 
@@ -0,0 +1 @@ 
+Chef Cookbook 
\ No newline at end of file 
[2017-01-12T21:07:49+01:00] INFO: entered create 
[2017-01-12T21:07:49+01:00] INFO: file[/tmp/book.txt] created file 
/tmp/book.txt

มันทำงานอย่างไร

  • Chef-Shell เริ่มต้นด้วยเซสชัน Interactive Ruby (IRB) ที่ปรับปรุงด้วยคุณสมบัติเฉพาะบางอย่าง

  • มีโหมดต่างๆเช่น attributes_mode และ interactive_mode

  • ช่วยในการเขียนคำสั่งซึ่งเขียนไว้ในสูตรอาหารหรือตำราอาหาร

  • มันทำงานทุกอย่างในโหมดโต้ตอบ

เราสามารถเรียกใช้ Chef-Shell ในสามโหมดที่แตกต่างกัน: Standalone mode, Client modeและ Solo mode.

  • Standalone mode- เป็นโหมดเริ่มต้น ไม่มีการโหลดตำราอาหารและรายการที่รันว่างเปล่า

  • Client mode - ที่นี่เชฟเชลล์ทำหน้าที่เป็นพ่อครัว - ลูกค้า

  • Solo mode - ที่นี่เชฟเชลล์ทำหน้าที่เป็นลูกค้าเดี่ยวของเชฟ

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

ต่อไปนี้เป็นขั้นตอนสำหรับการทดสอบ

Step 1 - ติดตั้งตำราอาหารโดยใช้คำสั่งต่อไปนี้

vipin@laptop:~/chef-repo $ knife cookbook site install <cookbook name>

Step 2 - เรียกใช้คำสั่งทดสอบมีดในตำราอาหารที่ใช้งานได้

vipin@laptop:~/chef-repo $ knife cookbook test VTest  
checking ntp 
Running syntax check on ntp 
Validating ruby files 
Validating templates

Step 3 - ทำลายบางสิ่งในตำราอาหารแล้วทดสอบอีกครั้ง

vipin@laptop:~/chef-repo $ subl cookbooks/VTest/recipes/default.rb 
... 
[ node['ntp']['varlibdir'] 
node['ntp']['statsdir'] ].each do |ntpdir| 
   directory ntpdir do 
      owner node['ntp']['var_owner'] 
      group node['ntp']['var_group'] 
      mode 0755 
   end 
end

Step 4 - รันคำสั่งทดสอบมีดอีกครั้ง

vipin@laptop:~/chef-repo $ knife cookbook test ntp 
checking ntp 
Running syntax check on ntp 
Validating ruby files 
FATAL: Cookbook file recipes/default.rb has a ruby syntax error: 
FATAL: cookbooks/ntp/recipes/default.rb:25: syntax error, 
unexpected tIDENTIFIER, expecting ']' 
FATAL: node['ntp']['statsdir'] ].each do |ntpdir| 
FATAL: ^ 
FATAL: cookbooks/ntp/recipes/default.rb:25: syntax error, 
unexpected ']', expecting $end 
FATAL: node['ntp']['statsdir'] ].each do |ntpdir| 
FATAL:

วิธีการทำงาน

การทดสอบ Knife Cookbook จะดำเนินการตรวจสอบไวยากรณ์ Ruby ในไฟล์ Ruby ทั้งหมดภายในตำราอาหารรวมทั้งเทมเพลต ERB ทั้งหมด มันวนซ้ำผ่านไฟล์ Ruby และเรียกใช้ Ruby–cกับแต่ละคน ทับทิม–c ตรวจสอบไวยากรณ์ของสคริปต์และออกโดยไม่ต้องเรียกใช้

หลังจากผ่านไฟล์ Ruby ทั้งหมดแล้วการทดสอบมีดตำราอาหารจะต้องผ่านเทมเพลตและไปป์ ERB ทั้งหมดซึ่งเป็นเวอร์ชันซ้ำซ้อนที่สร้างโดย –x ผ่าน Ruby –c.

ข้อ จำกัด

การทดสอบมีดตำราทำเพียงการตรวจสอบไวยากรณ์อย่างง่ายในไฟล์ Ruby และเทมเพลต ERB เราสามารถดำเนินการทดสอบอย่างเต็มที่โดยใช้ ChefSpec และห้องครัวทดสอบ

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

การตั้งค่า Foodcritic

Step 1 - เพิ่มอัญมณี Foodcritic

vipin@laptop:~/chef-repo $ subl Gemfile 
source 'https://rubygems.org' 
gem 'foodcritic', '~>2.2.0'

Step 2 - ติดตั้งอัญมณี

vipin@laptop:~/chef-repo $ bundle install 
Fetching gem metadata from https://rubygems.org/ 
...TRUNCATED OUTPUT... 
Installing foodcritic (2.2.0)

อัญมณีแห่งอาหาร

Step 1 - เรียกใช้ Foodcritic ในตำราอาหาร

vipin@laptop:~/chef-repo $ foodcritic ./cookbooks/<Cookbook Name> 
FC002: Avoid string interpolation where not required: ./cookbooks/ 
mysql/attributes/server.rb:220 
...TRUNCATED OUTPUT... 
FC024: Consider adding platform equivalents: ./cookbooks/<Cookbook Name>/ 
recipes/server.rb:132

Step 2 - สร้างรายงานโดยละเอียด

vipin@laptop:~/chef-repo $ foodcritic -C ./cookbooks/mysql 
cookbooks/<cookbook Name>/attributes/server.rb 
FC002: Avoid string interpolation where not required 
[...] 
85| default['<Cookbook Name>']['conf_dir'] = "#{mysql['basedir']}" 
[...] 
cookbooks/<Cookbook Name>/recipes/client.rb 
FC007: Ensure recipe dependencies are reflected in cookbook 
metadata 
40| end 
41|when "mac_os_x" 
42| include_recipe 'homebrew' 
43|end 
44|

วิธีการทำงาน

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

Test Driven Development (TDD)เป็นวิธีการเขียน unit test ก่อนที่จะเขียนรหัสสูตรอาหารจริง การทดสอบควรเป็นของจริงและควรตรวจสอบความถูกต้องของสูตรอาหาร มันควรจะล้มเหลวจริง ๆ เนื่องจากไม่มีการพัฒนาสูตรอาหาร เมื่อพัฒนาสูตรแล้วการทดสอบควรผ่าน

ChefSpec สร้างขึ้นบนเฟรมเวิร์ก RSpec ยอดนิยมและนำเสนอไวยากรณ์ที่ปรับแต่งสำหรับการทดสอบสูตรเชฟ

การสร้าง ChefSpec

Step 1 - สร้างไฟล์อัญมณีที่มีอัญมณี chefSpec

vipin@laptop:~/chef-repo $ subl Gemfile 
source 'https://rubygems.org' 
gem 'chefspec'

Step 2 - ติดตั้งอัญมณี

vipin@laptop:~/chef-repo $ bundler install 
Fetching gem metadata from https://rubygems.org/ 
...TRUNCATED OUTPUT... 
Installing chefspec (1.3.1) 
Using bundler (1.3.5) 
Your bundle is complete!

Step 3 - สร้างไดเร็กทอรีข้อมูลจำเพาะ

vipin@laptop:~/chef-repo $ mkdir cookbooks/<Cookbook Name>/spec

Step 4 - สร้าง Spec

vipin@laptop:~/chef-repo $ subl  
cookbooks/my_cookbook/spec/default_spec.rb  
require 'chefspec'  
describe 'my_cookbook::default' do  
   let(:chef_run) {  
      ChefSpec::ChefRunner.new(  
         platform:'ubuntu', version:'12.04'  
      ).converge(described_recipe)  
   }  

   it 'creates a greetings file, containing the platform  
   name' do  
      expect(chef_run).to  
      create_file_with_content('/tmp/greeting.txt','Hello! ubuntu!')  
   end  
end

Step 5 - ตรวจสอบ ChefSpec

vipin@laptop:~/chef-repo $ rspec cookbooks/<Cookbook Name>/spec/default_spec.rb 
F 
Failures: 
1) <CookBook Name> ::default creates a greetings file, containing the platform name 
Failure/Error: expect(chef_run.converge(described_recipe)).to 
create_file_with_content('/tmp/greeting.txt','Hello! ubuntu!') 
File content: 
does not match expected: 
Hello! ubuntu! 
# ./cookbooks/my_cookbook/spec/default_spec.rb:11:in `block 
(2 levels) in <top (required)>' 
Finished in 0.11152 seconds 
1 example, 1 failure  

Failed examples: 
rspec ./cookbooks/my_cookbook/spec/default_spec.rb:10 # my_ 
cookbook::default creates a greetings file, containing the 
platform name

Step 6 - แก้ไขสูตรเริ่มต้นของตำราอาหาร

vipin@laptop:~/chef-repo $ subl cookbooks/<Cookbook Name>/recipes/default.rb 
template '/tmp/greeting.txt' do 
   variables greeting: 'Hello!' 
end

Step 7 - สร้างไฟล์เทมเพลต

vipin@laptop:~/chef-repo $ subl cookbooks/< Cookbook Name>/recipes/default.rb 
<%= @greeting %> <%= node['platform'] %>!

Step 8 - เรียกใช้ rspec อีกครั้ง

vipin@laptop:~/chef-repo $ rspec cookbooks/<Cookbook Name>/spec/default_spec.rb 
. 
Finished in 0.10142 seconds 
1 example, 0 failures

มันทำงานอย่างไร

ก่อนอื่นเราต้องตั้งค่าโครงสร้างพื้นฐานพื้นฐานสำหรับการใช้ RSpec กับ Chef ก่อน จากนั้นเราต้องการอัญมณี ChefSpec Ruby และตำราอาหารต้องการไดเร็กทอรีที่เรียกว่า spec ที่ซึ่งการทดสอบทั้งหมดจะถูกบันทึกไว้

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

นี่คือสัญญาโหนดสำหรับ ChefSpec ซึ่งจำลองการทำงานของ Chef เท่านั้น Test Kitchen บูทโหนดจริงและเรียกใช้ Chef

การตั้งค่า

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

Step 1 - แก้ไขสูตรเริ่มต้นในตำราอาหาร

vipin@laptop:~/chef-repo $ subl cookbooks/<Cookbook Name>/recipes/default.rb 
file "/tmp/greeting.txt" do 
   content node['my_cookbook']['greeting'] 
end

Step 2 - แก้ไขแอตทริบิวต์ตำราอาหาร

vipin@laptop:~/chef-repo $ subl cookbooks/<Cookbook Name>/attributes/default.rb 
default['my_cookbook']['greeting'] = "Ohai, Chefs!"

Step 3 - แก้ไขไฟล์อัญมณีเพื่อติดตั้งอัญมณีทับทิมที่จำเป็น

vipin@laptop:~/chef-repo $ subl Gemfile 
gem 'test-kitchen', '~> 2.0.0.alpha.7' 
gem 'kitchen-vagrant'

Step 4 - ติดตั้งอัญมณีทับทิมที่จำเป็น

vipin@laptop:~/chef-repo $ bundle install 
...TRUNCATED OUTPUT... 
Installing test-kitchen (1.0.0.alpha.7) 
Installing kitchen-vagrant (0.10.0) ...TRUNCATED OUTPUT...

Step 5 - สร้างไฟล์. kitchen.yml ในตำราอาหาร

vipin@laptop:~/chef-repo/cookbooks/my_cookbook $ subl .kitchen.yml 
--- 
driver_plugin: vagrant 
driver_config: 
   require_chef_omnibus: true  
platforms: 
   - name: ubuntu-12.04 
  driver_config: 
      box: opscode-ubuntu-12.04 
      box_url: 
         https://opscode-vm.s3.amazonaws.com/vagrant/
            opscode_ubuntu12.04_provisionerless.box  
suites: 
   - name: default 
   run_list: 
      - recipe[minitest-handler] 
      - recipe[my_cookbook_test] 
attributes: { my_cookbook: { greeting: 'Ohai, Minitest!'} }

Step 6 - สร้างไดเรกทอรีทดสอบภายในตำราอาหาร

vipin@laptop:~/chef-repo/cookbooks/<Cookbook Name>$ mkdir test

Step 7 - สร้างตำราทดสอบสำหรับการทดสอบการรวมระบบ

vipin@laptop:~/chef-repo/cookbooks/<Cookbook Name>/test $ knife 
cookbook create my_cookbook_test 
** Creating cookbook my_cookbook_test 
** Creating README for cookbook: my_cookbook_test 
** Creating CHANGELOG for cookbook: my_cookbook_test 
** Creating metadata for cookbook: my_cookbook_test

Step 8 - แก้ไขตำราทดสอบสูตรเริ่มต้น

vipin@laptop:~/chef-repo/cookbooks/my_cookbook $ subl 
test/cookbooks/my_cookbook_test/recipes/default.rb 
include_recipe 'my_cookbook::default'

Step 9 - สร้าง Minitest Spec ในตำราอาหาร

vipin@laptop:~/chef-repo/cookbooks/my_cookbook $ mkdir -p 
   test/cookbooks/my_cookbook_test/files/default/tests/minitest  

vipin@laptop:~/chef-repo/cookbooks/my_cookbook $ subl 
   test/cookbooks/my_cookbook_test/files/default/tests/minitest/default_test.rb  

require 'minitest/spec'  
describe_recipe 'my_cookbook::default' do 
   describe "greeting file" do 
      it "creates the greeting file" do 
         file("/tmp/greeting.txt").must_exist 
      end 
       
      it "contains what's stored in the 'greeting' node 
         attribute" do 
         file('/tmp/greeting.txt').must_include 'Ohai, Minitest!' 
      end 
end

Step 10 - แก้ไข Berksfile ของตำราอาหารหลักของคุณ

vipin@laptop:~/chef-repo/cookbooks/my_cookbook $ subl Berksfile 
site :opscode 
metadata 
cookbook "apt" 
cookbook "minitest-handler" 
cookbook "my_cookbook_test", path: 
"./test/cookbooks/my_cookbook_test"

กำลังทดสอบการตั้งค่า

vipin@laptop:~/chef-repo/cookbooks/my_cookbook $ kitchen test 
-----> Starting Kitchen (v1.0.0.alpha.7) 
...TRUNCATED OUTPUT... 
-----> Converging <default-ubuntu-1204> 
-----> Installing Chef Omnibus (true) 
...TRUNCATED OUTPUT... 
Starting Chef Client, version 11.4.4 
[2013-06-29T18:33:57+00:00] INFO: *** Chef 11.4.4 *** 
[2013-06-29T18:33:58+00:00] INFO: Setting the run_list to 
["recipe[minitest-handler]", "recipe[my_cookbook_test]"] 
from JSON 
...TRUNCATED OUTPUT... 
# Running tests: 
recipe::my_cookbook::default::greeting 
file#test_0001_creates the greeting file = 0.00 s = . 
recipe::my_cookbook::default::greeting 
file#test_0002_contains what's stored in the 'greeting' 
node attribute = 0.00 s = . 
Finished tests in 0.011190s, 178.7277 tests/s, 178.7277 
assertions/s. 
2 tests, 2 assertions, 0 failures, 0 errors, 0 skips 
...TRUNCATED OUTPUT...  
-----> Kitchen is finished. (2m5.69s)

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

เริ่มต้นใช้งาน

ในการเริ่มต้นเราจำเป็นต้องติดตั้งอัญมณีมีดพรีไลท์

Step 1 - กำหนดเส้นทางในไฟล์อัญมณี

vipin@laptop:~/chef-repo $ subl Gemfile 
source 'https://rubygems.org' 
gem 'knife-preflight'

Step 2 - เรียกใช้บันเดิลเลอร์เพื่อติดตั้งมีด preflight gem

vipin@laptop:~/chef-repo $ bundle install 
Fetching gem metadata from https://rubygems.org/ 
...TRUNCATED OUTPUT... 
Installing knife-preflight (0.1.6)

วิธีการทำงาน

เรียกใช้ knife-preflight บนตำราอาหารที่กำหนด

เราสามารถเรียกใช้คำสั่ง preflight เพื่อค้นหาว่าโหนดและบทบาทใดมีตำราอาหารที่กำหนดในรายการการรันที่ขยายออก

vipin@laptop:~/chef-repo $ knife preflight ntp 
Searching for nodes containing ntp OR ntp::default in their 
expanded run_list... 
2 Nodes found 
www-staging.example.com 
cms-staging.example.com 
Searching for roles containing ntp OR ntp::default in their 
expanded run_list... 
3 Roles found 
your_cms_role 
your_www_role 
your_app_role 
Found 6 nodes and 3 roles using the specified search 
criteria

มีหลายวิธีสำหรับตำราอาหารในการดำเนินการบนโหนด

  • คุณสามารถกำหนดตำราอาหารให้กับโหนดได้โดยตรงโดยเพิ่มลงในรายการรันของโหนด

  • คุณสามารถเพิ่มตำราอาหารลงในบทบาทและเพิ่มบทบาทในรายการเรียกใช้ของโหนด

  • คุณสามารถเพิ่มบทบาทลงในรายการรันของบทบาทอื่นและเพิ่มบทบาทอื่นนั้นในรายการรันของโหนด

  • ตำราอาหารอาจเป็นที่พึ่งพาของตำราอาหารมือสองอื่น ๆ

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

ในการทดสอบการเรียกใช้ Chef-Client เราจำเป็นต้องกำหนดค่า Chef-Client ให้ใช้ Chef ที่โฮสต์หรือเซิร์ฟเวอร์ที่โฮสต์เอง

เรียกใช้ Chef-Client ในโหมด Debug

vipin@server:~$ sudo chef-client -l debug 
…TRUNCATED OUTPUT… 
Hashed Path:A+WOcvvGu160cBO7IFKLYPhh9fI= 
X-Ops-Content-Hash:2jmj7l5rSw0yVb/vlWAYkK/YBwk= 
X-Ops-Timestamp:2012-12-27T11:14:07Z 
X-Ops-UserId:vagrant' 
Header hash: {"X-Ops-Sign"=>"algorithm=sha1;version=1.0;", 
"X-Ops-Userid"=>"vagrant", "X-Ops-Timestamp"=>"2012-12- 
27T11:14:07Z", "X-Ops-Content- 
Hash"=>"2jmj7l5rSw0yVb/vlWAYkK/YBwk=", "X-Ops- 
Authorization- 
1"=>"HQmTt9U/ 
LJJVAJXWtyOu3GW8FbybxAIKp4rhiw9O9O3wtGYVHyVGuoilWDao", 
"X-Ops-Authorization- 
2"=>"2/uUBPWX+YAN0g1/ 
fD2854QAU2aUcnSaVM0cPNNrldoOocmA0U5HXkBJTKok", 
"X-Ops-Authorization- 
3"=>"6EXPrEJg5T+ 
ddWd5qHAN6zMqYc3untb41t+eBpigGHPhtn1LLInMkPeIYwBm", 
"X-Ops-Authorization- 
4"=>"B0Fwbwz2HVP3wEsYdBGu7yOatq7fZBXHfIpeOi0kn/ 
Vn0P7HrucnOpONmMgU", "X-Ops-Authorization- 
5"=>"RBmmbetFSKCYsdg2v2mW/ 
ifLIVemhsHyOQjffPYPpNIB3U2n7vji37NxRnBY", 
"X-Ops-Authorization- 
6"=>"Pb3VM7FmY60xKvWfZyahM8y8WVV9xPWsD1vngihjFw=="} 
[2012-12-27T11:14:07+00:00] DEBUG: Sending HTTP Request via 
GET to api.opscode.com:443/organizations/agilewebops/ 
nodes/vagrant
[2012-12-27T11:14:09+00:00] DEBUG: ---- HTTP Status and 
Header Data: ---- 
[2012-12-27T11:14:09+00:00] DEBUG: HTTP 1.1 200 OK 
[2012-12-27T11:14:09+00:00] DEBUG: server: nginx/1.0.5 
[2012-12-27T11:14:09+00:00] DEBUG: date: Thu, 27 Dec 2012

ตรวจสอบผลลัพธ์ของ Chef-Client Run ครั้งล่าสุด

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

หากต้องการทดสอบเราจำเป็นต้องมีตำราอาหารที่ใช้งานไม่ได้ซึ่งไม่สามารถรวบรวมได้

user@server:~$ sudo chef-client 
================================================================== 
============== 
Recipe Compile Error in /srv/chef/file_store/cookbooks/my_ 
cookbook/recipes/default.rb 
================================================================== 
============== 
NoMethodError 
------------- 
undefined method `each' for nil:NilClass 
Cookbook Trace: 
--------------- 
/srv/chef/file_store/cookbooks/my_cookbook/recipes/default. 
rb:9:in `from_file' 
Relevant File Content: 
---------------------- 
/srv/chef/file_store/cookbooks/my_cookbook/recipes/default.rb: 
2: # Cookbook Name:: my_cookbook 
3: # Recipe:: default 
4: # 
5: # Copyright 2013, YOUR_COMPANY_NAME 
6: # 
7: # All rights reserved - Do Not Redistribute 
8: # 
9≫ nil.each {}  
10:

สำหรับรายละเอียดเพิ่มเติมเราสามารถดูใน stacktrace

user@server:~$ less /srv/chef/file_store/chef-stacktrace.out 
Generated at 2013-07-21 18:34:05 +0000 
NoMethodError: undefined method `each' for nil:NilClass 
/srv/chef/file_store/cookbooks/my_cookbook/recipes/default.rb:9:in 
`from_file' 
/opt/chef/embedded/lib/ruby/gems/1.9.1/gems/chef-11.4.4/lib/chef/ 
mixin/from_file.rb:30:in `instance_eval' 
/opt/chef/embedded/lib/ruby/gems/1.9.1/gems/chef-11.4.4/lib/chef/ 
mixin/from_file.rb:30:in `from_file' 
/opt/chef/embedded/lib/ruby/gems/1.9.1/gems/chef-11.4.4/lib/chef/ 
cookbook_version.rb:346:in `load_recipe'

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

Step 1 - สร้างไฟล์เริ่มต้นสำหรับแอตทริบิวต์ตำราอาหารและเพิ่มแอตทริบิวต์เริ่มต้นลงไป

vipin@laptop:~/chef-repo $ subl cookbooks/my_cookbook/attributes/default.rb 
default['my_cookbook']['message'] = 'hello world!'

Step 2 - กำหนดคุณสมบัติภายในสูตร

vipin@laptop:~/chef-repo $ subl cookbooks/<Cookbook Name>/recipes/default.rb 
message = node['my_cookbook']['message'] 
Chef::Log.info("** Saying what I was told to say: #{message}")

Step 3 - อัปโหลดตำราอาหารที่แก้ไขแล้ว

vipin@laptop:~/chef-repo $ knife cookbook upload my_cookbook 
Uploading my_cookbook [0.1.0]

Step 4 - เรียกใช้ Chef-Client ของโหนดที่กำหนด

user@server:~$ sudo chef-client 
...TRUNCATED OUTPUT... 
[2013-01-13T20:48:21+00:00] INFO: ** Saying what I was told to 
say: hello world! 
...TRUNCATED OUTPUT...

วิธีการทำงาน

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

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

การลบล้างแอตทริบิวต์ที่ระดับโหนดและสภาพแวดล้อม

แอตทริบิวต์ที่กำหนดไว้ในบทบาทหรือสภาพแวดล้อมมีความสำคัญสูงสุด

Step 1 - สร้างบทบาท

vipin@laptop:~/chef-repo $ subl roles/german_hosts.rb 
name "german_hosts" 
description "This Role contains hosts, which should print out 
their messages in German" 
run_list "recipe[my_cookbook]" 
default_attributes "my_cookbook" => { "message" => "Hallo Welt!" }

Step 2 - อัปโหลดบทบาทไปยังเซิร์ฟเวอร์ Chef

vipin@laptop:~/chef-repo $ knife role from file german_hosts.rb 
Updated Role german_hosts!

Step 3 - กำหนดบทบาทให้กับโหนด

vipin@laptop:~/chef-repo $ knife node edit server 
"run_list": [ 
   "role[german_hosts]" 
] 
Saving updated run_list on node server

Step 4 - เรียกใช้ Chef-Client

user@server:~$ sudo chef-client 
...TRUNCATED OUTPUT... 
[2013-01-13T20:49:49+00:00] INFO: ** Saying what I was told to 
say: Hallo Welt! 
...TRUNCATED OUTPUT...

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

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

วิธีการใช้งาน

Step 1 - เพิ่มเทมเพลตลงในสูตรอาหาร

vipin@laptop:~/chef-repo $ subl cookbooks/<Cookbook Name>/recipes/default.rb  
template '/tmp/message' do 
   source 'Test.erb' 
   variables( 
      hi: 'Tesing', 
      world: 'Welt', 
      from: node['fqdn'] 
   ) 
end

Step 2 - เพิ่ม ERB ไฟล์เทมเพลต

vipin@laptop:~/chef-repo $ subl cookbooks/<Cookbook Name>/templates/default/test.erb 
<%- 4.times do %> 
<%= @hi %>, <%= @world %> from <%= @from %>! 
<%- end %>

Step 3 - อัปโหลดตำราอาหารที่แก้ไขไปยังเซิร์ฟเวอร์ Chef

vipin@laptop:~/chef-repo $ knife cookbook upload <Cookbook Name> 
Uploading my_cookbook [0.1.0] 
Run Chef Client on your node: 
user@server:~$ sudo chef-client 
...TRUNCATED OUTPUT... 
[2017-01-14T20:41:21+00:00] INFO: Processing template[/tmp/ 
message] action create (my_cookbook::default line 9) 
[2017-01-14T20:41:22+00:00] INFO: template[/tmp/message] updated 
content

Step 4 - ตรวจสอบเนื้อหาของไฟล์ที่อัปโหลด

user@server:~$ sudo cat /tmp/message 
Hallo, Welt from vagrant.vm! 
Hallo, Welt from vagrant.vm! 
Hallo, Welt from vagrant.vm! 
Hallo, Welt from vagrant.vm!

เวิร์กโฟลว์

เชฟใช้ภาษาเอรูบิสเป็นภาษาแม่แบบ อนุญาตให้ฝังรหัส Ruby บริสุทธิ์ไว้ในสัญลักษณ์พิเศษในเทมเพลต

  • ใช้ <% =%> หากคุณต้องการพิมพ์ค่าของตัวแปรหรือนิพจน์ Ruby ลงในไฟล์ที่สร้างขึ้น

  • <% -%> ใช้หากคุณต้องการฝังลอจิก Ruby ลงในไฟล์เทมเพลตของคุณ เราใช้มันเพื่อวนซ้ำนิพจน์ของเราสี่ครั้ง

ใน Chef หากต้องการสร้างสูตรอาหารง่ายๆเราสามารถใช้ทรัพยากรที่มีอยู่ใน Chef เช่นเทมเพลต remote_file และบริการ อย่างไรก็ตามเมื่อสูตรอาหารมีความซับซ้อนเราก็ต้องใช้เทคนิคขั้นสูงเช่นข้อความที่มีเงื่อนไขเพื่อดำเนินการบางส่วนของสูตรตามเงื่อนไข นี่คือพลังของการผสม Ruby ธรรมดากับภาษาเฉพาะของ Chef Domain (DSL)

วิธีการใช้งาน

เริ่ม Chef Shell บนโหนดใดก็ได้ในโหมดไคลเอนต์เพื่อให้สามารถเข้าถึงเซิร์ฟเวอร์ Chef

user@server:~$ sudo chef-shell --client 
loading configuration: /etc/chef/client.rb 
Session type: client 
...TRUNCATED OUTPUT... 
run `help' for help, `exit' or ^D to quit. 
Ohai2u user@server! 
Chef>

เงื่อนไขพื้นฐานกับ Chef DSL

เรียงโหนดตามชื่อโดยใช้ Ruby ธรรมดา

chef > nodes.sort! {|a,b| a.name <=> b.name } 
=> [node[alice],node[server]]

วนรอบโหนดพิมพ์ระบบปฏิบัติการ

chef > nodes.each do |n| 
   chef > puts n['os'] 
   chef ?> 
end  
linux 
windows 
=> [node[server], node[alice]]

ติดตั้งอัญมณี Ruby หลายตัวโดยใช้อาร์เรย์การขยายวงและสตริงเพื่อสร้างชื่ออัญมณี

chef > %w{ec2 essentials}.each do |gem| 
   chef > gem_package "knife-#{gem}" 
   chef ?> end   => ["ec2", "essentials"]

วิธีการทำงาน

สูตรอาหารของเชฟคือไฟล์ Ruby ซึ่งได้รับการประเมินในบริบทของ Chef run พวกเขาสามารถมีรหัส Ruby ธรรมดาเช่นคำสั่ง if และลูปเช่นเดียวกับองค์ประกอบ Chef DSL เช่นทรัพยากร

ภายในสูตรสามารถประกาศตัวแปร Ruby และกำหนดค่าให้ได้

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

สูตรเชฟมีความสามารถในการรับอัญมณีทับทิมที่ต้องการเพื่อใช้ในสูตรเดียวกัน

ใช้ iptable Gem ในสูตรอาหารที่กำหนด

Step 1 - แก้ไขสูตรเริ่มต้นของตำราอาหารและติดตั้งอัญมณีที่จะใช้ภายในสูตร

vipin@laptop:~/chef-repo $ subl 
cookbooks/my_cookbook/recipes/default.rb 
chef_gem 'ipaddress' 
require 'ipaddress' 
ip = IPAddress("192.168.0.1/24") 
Chef::Log.info("Netmask of #{ip}: #{ip.netmask}")

Step 2 - อัปโหลดตำราอาหารที่แก้ไขไปยังเซิร์ฟเวอร์ Chef

vipin@laptop:~/chef-repo $ knife cookbook upload my_cookbook 
Uploading my_cookbook [0.1.0]

Step 3 - เรียกใช้ลูกค้า Chef เพื่อดูผลลัพธ์

user@server $ sudo chef-client 
...TRUNCATED OUTPUT... 
[2013-01-18T14:02:02+00:00] INFO: Netmask of 192.168.0.1: 
255.255.255.0 
...TRUNCATED OUTPUT...

วิธีการทำงาน

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

ทรัพยากร chef_gem จะทำเหมือนกันทุกประการและใน Chef นั้น Omnibus เป็นวิธีเดียวในการทำงาน หน้าที่หลักของมันคือการสร้างอัญมณีให้กับเชฟเอง

ห้องสมุดใน Chef เป็นสถานที่สำหรับห่อหุ้มตรรกะที่รวบรวมเพื่อให้สูตรอาหารในตำราอาหารยังคงเรียบร้อยและสะอาด

การสร้างไลบรารี

Step 1 - สร้างวิธีการช่วยเหลือในห้องสมุดของตำราอาหาร

vipin@laptop:~/chef-repo $ subl cookbooks/my_cookbook/libraries/ipaddress.rb 
class Chef::Recipe 
def netmask(ipaddress) 
IPAddress(ipaddress).netmask 
end 
end

Step 2 - ใช้วิธีการช่วยเหลือ

vipin@laptop:~/chef-repo $ subl cookbooks/my_cookbook/recipes/default.rb 
ip = '10.10.0.0/24' 
mask = netmask(ip) # here we use the library method 
Chef::Log.info("Netmask of #{ip}: #{mask}")

Step 3 - อัปโหลดตำราอาหารที่แก้ไขไปยังเซิร์ฟเวอร์เชฟ

vipin@laptop:~/chef-repo $ knife cookbook upload my_cookbook 
Uploading my_cookbook [0.1.0]

การทดสอบไลบรารี

user@server $ sudo chef-client 
...TRUNCATED OUTPUT... 
[2013-01-18T14:38:26+00:00] INFO: Netmask of 10.10.0.0/24: 
255.255.255.0 
...TRUNCATED OUTPUT...

วิธีการทำงาน

รหัสห้องสมุด Chef สามารถเปิดคลาส Chef :: Recipe และเพิ่มวิธีการใหม่ได้ตามขั้นตอนที่ 1 ขั้นตอนนี้ไม่ใช่วิธีที่สะอาดที่สุด แต่เป็นวิธีที่ง่ายที่สุดในการทำ

class Chef::Recipe 
def netmask(ipaddress) 
... 
end 
end

ปฏิบัติที่ดีที่สุด

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

vipin@laptop:~/chef-repo $ subl cookbooks/my_cookbook/libraries/ipaddress.rb 
class Chef::Recipe::IPAddress 
def self.netmask(ipaddress) 
IPAddress(ipaddress).netmask 
end 
end

เราสามารถใช้วิธีการในสูตรเช่น

IPAddress.netmask(ip)

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

ในการทำเช่นนี้เราควรมีสูตรอาหาร ในกรณีนี้เราใช้ test_cookbook และรายการโหนดซึ่งรวมถึงตำราอาหาร

การสร้างคำจำกัดความ

Step 1 - สร้างไฟล์ข้อกำหนดใหม่ในโฟลเดอร์คำจำกัดความของตำราอาหาร

vipin@laptop:~/chef-repo $ subl cookbooks/test_cookbook/definitions/ 
capistrano_deploy_dirs.rb 
define :capistrano_deploy_dirs, :deploy_to => '' do 
   directory "#{params[:deploy_to]}/releases" 
   directory "#{params[:deploy_to]}/shared" 
   directory "#{params[:deploy_to]}/shared/system" 
end

Step 2 - ใช้คำจำกัดความภายในสูตรเริ่มต้นของตำราอาหาร

vipin@laptop:~/chef-repo $ subl cookbooks/test_cookbook/recipes/default.rb 
capistrano_deploy_dirs do 
   deploy_to "/srv" 
end

Step 3 - อัปโหลดตำราอาหารไปยังเซิร์ฟเวอร์พ่อครัว

vipin@laptop:~/chef-repo $ knife cookbook upload test_cookbook 
Uploading test_cookbook [0.1.0]

Step 4 - เรียกใช้ไคลเอ็นต์ Chef บนโหนดที่ต้องการ

vipin@laptop:~/chef-repuser@server $ sudo chef-client 
...TRUNCATED OUTPUT... 
[2013-01-18T16:31:11+00:00] INFO: Processing directory[/srv/ 
releases] action create (my_cookbook::default line 2) 
[2013-01-18T16:31:11+00:00] INFO: directory[/srv/releases] created 
directory /srv/releases 
[2013-01-18T16:31:11+00:00] INFO: Processing directory[/srv/ 
shared] action create (my_cookbook::default line 3) 
[2013-01-18T16:31:11+00:00] INFO: directory[/srv/shared] created 
directory /srv/shared 
[2013-01-18T16:31:11+00:00] INFO: Processing directory[/srv/ 
shared/system] action create (my_cookbook::default line 4) 
[2013-01-18T16:31:11+00:00] INFO: directory[/srv/shared/system]

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

ในคำจำกัดความเรามีพารามิเตอร์ซึ่งในโค้ดของเรามีลักษณะดังต่อไปนี้

….. 
directory "#{params[:deploy_to]}/releases" 
directory "#{params[:deploy_to]}/shared" 
directory "#{params[:deploy_to]}/shared/system” 
……

สามารถใช้ภายในสูตรเริ่มต้นได้ดังนี้

capistrano_deploy_dirs do 
   deploy_to "/srv"` 
end

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

ในการทำเช่นนี้เราต้องมีตำราอาหารที่นี่เราจะใช้ test_cookbook และรายการเรียกใช้ซึ่งมี test_cookbook

การตั้งค่าตัวแปรสภาพแวดล้อมโดยใช้ Chef Recipe

Step 1 - อัปเดตสูตรเริ่มต้นของตำราอาหารด้วยตัวแปรสภาพแวดล้อม

vipin@laptop:~/chef-repo $ subl cookbooks/test_cookbook/recipes/default.rb  
ENV['MESSAGE'] = 'Testing environment variable update with chef !'  
execute 'print value of environment variable $MESSAGE' do command 'echo $MESSAGE > /tmp/message' 
end

Step 2 - อัปโหลดตำราอาหารที่อัปเดตไปยังเซิร์ฟเวอร์

vipin@laptop:~/chef-repo $ knife cookbook upload test_cookbook 
Uploading my_cookbook [0.1.0]

Step 3 - เรียกใช้ไคลเอนต์ Chef เพื่อสร้างไฟล์ชั่วคราว

user@server:~$ sudo chef-client 
...TRUNCATED OUTPUT... 
[2013-01-25T15:01:57+00:00] INFO: Processing execute[print 
value of environment variable $MESSAGE] action run (my_cookbook::default line 11) [2013-01-25T15:01:57+00:00] INFO: execute[print value of environment variable $MESSAGE] ran successfully 
...TRUNCATED OUTPUT...

กำลังตรวจสอบตัวแปร

user@server:~$ cat /tmp/message 
Hello from Chef

วิธีการทำงาน

Ruby เปิดเผยตัวแปรสภาพแวดล้อมปัจจุบันผ่าน ENV –a แฮชเพื่ออ่านและแก้ไขตัวแปรสภาพแวดล้อม

ดำเนินการทรัพยากร

เราสามารถใช้ execute resource เพื่อทำแบบเดียวกันในตำราอาหารเริ่มต้นของ Chef

mma@laptop:~/chef-repo $ subl cookbooks/test_cookbook/recipes/default.rb  
execute 'print value of environment variable $MESSAGE' do command 'echo $MESSAGE > /tmp/message' 
   environment 'MESSAGE' => 'Hello from the execute resource' 
end

Note- การตั้งค่าตัวแปรสภาพแวดล้อมโดยใช้ ENV จะทำให้ตัวแปรนั้นพร้อมใช้งานในระหว่างการเรียกใช้ Chef ทั้งหมด ในทางตรงกันข้ามการส่งไปยังรีซอร์ส execute จะทำให้พร้อมใช้งานสำหรับคำสั่งเดียวที่ดำเนินการโดยทรัพยากร

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

วิธีการทำงาน

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

Step 1 - สร้างไดเร็กทอรีสำหรับกระเป๋าข้อมูลของเรา

mma@laptop:~/chef-repo $ mkdir data_bags/hooks

Step 2- สร้างรายการกระเป๋าข้อมูลสำหรับถังคำขอ ต้องตรวจสอบให้แน่ใจว่ามีการใช้ requestBin URL ที่กำหนดไว้

vipi@laptop:~/chef-repo $ subl data_bags/hooks/request_bin.json { 
   "id": "request_bin", 
   "url": "http://requestb.in/1abd0kf1" 
}

Step 3 - สร้างกระเป๋าข้อมูลบนเซิร์ฟเวอร์ Chef

vipin@laptop:~/chef-repo $ knife data bag create hooks 
Created data_bag[hooks]

Step 4 - อัปโหลดกระเป๋าข้อมูลไปยังเซิร์ฟเวอร์ Chef

vipin@laptop:~/chef-repo $ knife data bag from file hooks requestbin.json 
Updated data_bag_item[hooks::RequestBin]

Step 5 - อัปเดตสูตรเริ่มต้นของตำราอาหารเพื่อรับตำราอาหารที่ต้องการจากกระเป๋าข้อมูล

vipin@laptop:~/chef-repo $ subl cookbooks/my_cookbook/recipes/default.rb 
hook = data_bag_item('hooks', 'request_bin') 
http_request 'callback' do 
   url hook['url'] 
end

Step 6 - อัปโหลดตำราอาหารที่แก้ไขไปยังเซิร์ฟเวอร์ Chef

vipin@laptop:~/chef-repo $ knife cookbook upload my_cookbook 
Uploading my_cookbook [0.1.0]

Step 7 - รันไคลเอนต์ Chef บนโหนดเพื่อตรวจสอบว่าถังคำขอ http ถูกเรียกใช้งานหรือไม่

user@server:~$ sudo chef-client 
...TRUNCATED OUTPUT... 
[2013-02-22T20:37:35+00:00] INFO: http_request[callback] 
GET to http://requestb.in/1abd0kf1 successful 
...TRUNCATED OUTPUT...

มันทำงานอย่างไร

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

เราสร้างกระเป๋าข้อมูลที่เรียกว่าตะขอ ถุงข้อมูลคือไดเร็กทอรีภายในที่เก็บ Chef เราใช้มีดเพื่อสร้างมันบนเซิร์ฟเวอร์

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

สำหรับสิ่งนี้ต้องมีตำราอาหาร ในกรณีของเราเราจะใช้ test_cookbook เหมือนก่อนหน้านี้และควรมีรายการ run ของโหนดรวมถึงคำจำกัดความ test_cookbook อยู่ด้วย

วิธีการทำงาน

Step 1 - สร้างกระเป๋าข้อมูล

vipin@laptop:~/chef-repo $ mkdir data_bags/servers 
vipin@laptop:~/chef-repo $ knife data bag create servers 
Created data_bag[servers]

Step 2 - สร้างรายการกระเป๋าข้อมูล

vipin@laptop:~/chef-repo $ subl data_bags/servers/Storage.json { 
   "id": "storage", 
   "host": "10.0.0.12" 
}

Step 3 - อัปเดตรายการกระเป๋าข้อมูล

vipin@laptop:~/chef-repo $ subl data_bags/servers/Storage.json { 
   "id": "storage", 
   "host": "10.0.0.12" 
}

ใช้ในตำราอาหาร

Step 1 - ต้องสร้างไฟล์ JSON ที่มีค่าถุงข้อมูลโดยใช้ตำราอาหารข้างต้นเพื่อให้สคริปต์ภายนอกสามารถเข้าถึงค่าเหล่านั้นได้

vipin@laptop:~/chef-repo $ subl cookbooks/test_cookbook/recipes/default.rb 
file "/etc/backup_config.json" do 
   owner "root"
   group "root" 
   mode 0644 
   content data_bag_item('servers', 'backup')['host'].to_json 
end

Step 2 - อัปโหลด test_cookbook ไปยังเซิร์ฟเวอร์ Chef

vipin@laptop:~/chef-repo $ knife cookbook upload test_cookbook 
Uploading my_cookbook [0.1.0]

Step 3 - เรียกใช้ไคลเอ็นต์ Chef บนโหนด

user@server:~$ sudo chef-client 
...TRUNCATED OUTPUT... 
[2013-03-14T20:30:33+00:00] INFO: Processing 
file[/etc/backup_config.json] action create 
(my_cookbook::default line 9) 
[2013-03-14T20:30:34+00:00] INFO: entered create 
[2013-03-14T20:30:34+00:00] INFO: 
file[/etc/backup_config.json] owner changed to 0 
[2013-03-14T20:30:34+00:00] INFO: 
file[/etc/backup_config.json] group changed to 0 
[2013-03-14T20:30:34+00:00] INFO: 
file[/etc/backup_config.json] mode changed to 644 
[2013-03-14T20:30:34+00:00] INFO: 
file[/etc/backup_config.json] created file 
/etc/backup_config.json 
...TRUNCATED OUTPUT...

Step 4 - ตรวจสอบเนื้อหาของไฟล์ JSON ที่สร้างขึ้น

user@server:~$ cat /etc/backup_config.json 
"10.0.0.12"

เวิร์กโฟลว์ของสคริปต์

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

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

ในการทำเช่นนี้เราต้องมีตำราอาหาร ในกรณีของเรามันจะเป็น test_cookbook และ run list ซึ่งจะมีคำจำกัดความของตำราอาหารอยู่

วิธีการทำงาน

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

Step 1 - บันทึกข้อความหากโหนดเป็น Ubuntu

vipin@laptop:~/chef-repo $ subl cookbooks/test_cookbook/recipes/default.rb 
Log.info("Running on ubuntu") if node.platform['ubuntu']

Step 2 - อัปโหลดตำราอาหารไปยังเซิร์ฟเวอร์ Chef

vipin@laptop:~/chef-repo $ subl cookbooks/test_cookbook/recipes/default.rb 
Uploading my_cookbook [0.1.0] 
Uploaded 1 cookbook.

Step 3 - เรียกใช้ไคลเอ็นต์ Chef บนโหนด

user@server:~$ sudo chef-client 
...TRUNCATED OUTPUT... 
[2013-03-03T20:07:39+00:00] INFO: Running on Ubuntu 
...TRUNCATED OUTPUT...

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

Log.info("Running on a debian derivative") if 
platform_family?('debian')

การอัปโหลดตำราอาหารที่แก้ไขแล้วและเรียกใช้ไคลเอนต์ Chef บนโหนด Ubuntu จะแสดงผลลัพธ์ต่อไปนี้

[2013-03-03T20:16:14+00:00] INFO: Running on a debian 
derivative

เวิร์กโฟลว์ของสคริปต์

ในคำสั่งดังกล่าว Ohai จะค้นพบสถานะปัจจุบันของระบบปฏิบัติการของโหนดและจัดเก็บเป็นแอตทริบิวต์แพลตฟอร์มพร้อมกับอ็อบเจ็กต์โหนด

node['platform']

หรือคุณสามารถใช้ไวยากรณ์สไตล์วิธีการ -

node.platform

การตั้งค่าเฉพาะแพลตฟอร์ม

ในการกำหนดค่าเฉพาะแพลตฟอร์มเชฟเสนอวิธีการอำนวยความสะดวก value_for_platform และ value_for_platform_family สามารถใช้เพื่อหลีกเลี่ยง case statement ที่ซับซ้อนและใช้แฮชธรรมดาแทน

ตัวอย่างตำราอาหาร

execute "start-runsvdir" do 
   command value_for_platform( 
      "debian" => { "default" => "runsvdir-start" }, 
      "ubuntu" => { "default" => "start runsvdir" }, 
      "gentoo" => { "default" => "/etc/init.d/runit-start start" } 
   ) 
   action :nothing 
end

ในตัวอย่างข้างต้นคำสั่งคือ OS เฉพาะตามที่กำหนดไว้

  • สำหรับ Debian "runvdir-start" จะทำงาน
  • สำหรับ Ubuntu "start runningvdir" จะทำงาน
  • สำหรับ Gentoo "/etc/init.d/runit-start" จะทำงาน

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

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

ไวยากรณ์ทรัพยากร

type 'name' do 
   attribute 'value' 
   action :type_of_action 
end

ในไวยากรณ์ข้างต้น 'type' คือประเภททรัพยากรและ 'name' คือชื่อที่เราจะใช้ ในบล็อก "do" และ "end" เรามีคุณลักษณะของทรัพยากรนั้นและการดำเนินการที่เราต้องดำเนินการสำหรับทรัพยากรนั้น ๆ

ทรัพยากรทั้งหมดที่เราใช้ในสูตรอาหารมีชุดการดำเนินการของตัวเองซึ่งกำหนดไว้ในบล็อก "do" และ "end"

ตัวอย่าง

type 'name' do 
   attribute 'value' 
   action :type_of_action 
end

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

การดำเนินการ :nothing การดำเนินการสามารถใช้กับทรัพยากรใด ๆ หรือทรัพยากรที่กำหนดเอง
คุณสมบัติ คุณสมบัติ Ignore_failure, provider, retry, retry_delay และ support สามารถใช้กับทรัพยากรหรือทรัพยากรที่กำหนดเองได้
ยาม การดำเนินการตามเงื่อนไข not_if และ only_if สามารถใช้เพื่อเพิ่มยามเพิ่มเติมรอบ ๆ ทรัพยากรบางอย่างเพื่อให้พวกเขาทำงานเมื่อตรงตามเงื่อนไขเท่านั้น
ล่ามยาม ประเมินคำสั่งสตริงโดยใช้ไฟล์ script- ตามทรัพยากร: bash, csh, perl, powershell_script, python, หรือ ruby.
การแจ้งเตือน การแจ้งเตือนการแจ้งเตือนและการสมัครสมาชิกสามารถใช้กับทรัพยากรใดก็ได้
เส้นทางสัมพัทธ์ สามารถใช้พา ธ สัมพัทธ์ # {ENV ['HOME']} กับทรัพยากรใดก็ได้
ความปลอดภัยของไฟล์ Windows template, file, remote_file, cookbook_file, directory, และ remote_directory ทรัพยากรสนับสนุนการใช้มรดกและรายการควบคุมการเข้าถึง (ACL) ภายในสูตรอาหาร
ทำงานใน Compile Phase บางครั้งทรัพยากรต้องถูกรันก่อนทรัพยากรอื่น ๆ หรือหลังจากเพิ่มทรัพยากรทั้งหมดในคอลเล็กชันทรัพยากรแล้ว

ทรัพยากรที่มีอยู่

apt_package

ใช้ apt_package ทรัพยากรในการจัดการแพ็คเกจสำหรับแพลตฟอร์ม Debian และ Ubuntu

ทุบตี

ใช้ bashทรัพยากรในการรันสคริปต์โดยใช้ Bash interpreter ทรัพยากรนี้อาจใช้การดำเนินการและคุณสมบัติใด ๆ ที่พร้อมใช้งานสำหรับไฟล์executeทรัพยากร. คำสั่งที่ดำเนินการกับรีซอร์สนี้คือ (โดยธรรมชาติ) ไม่ใช่ idempotent เนื่องจากโดยทั่วไปแล้วจะไม่ซ้ำกับสภาพแวดล้อมที่รันอยู่ ใช้ not_if และ only_if เพื่อป้องกันทรัพยากรนี้เพื่อความเป็นส่วนตัว

แบทช์

ใช้ batchทรัพยากรในการรันสคริปต์แบตช์โดยใช้ตัวแปล cmd.exe batch ทรัพยากรสร้างและเรียกใช้ไฟล์ชั่วคราว (คล้ายกับวิธีการ script ทรัพยากรทำงาน) แทนที่จะเรียกใช้คำสั่งแบบอินไลน์

ทรัพยากรนี้สืบทอดการกระทำ (: run and: nothing) และคุณสมบัติ (สร้าง, cwd, สภาพแวดล้อม, กลุ่ม, เส้นทาง, ระยะหมดเวลาและผู้ใช้) จาก executeทรัพยากร. คำสั่งที่ดำเนินการกับรีซอร์สนี้คือ (โดยธรรมชาติ) ไม่ใช่ idempotent เนื่องจากโดยทั่วไปแล้วจะไม่ซ้ำกับสภาพแวดล้อมที่รันอยู่ ใช้not_if และ only_if เพื่อปกป้องทรัพยากรนี้เพื่อความเป็นส่วนตัว

bff_package

ใช้ bff_package ทรัพยากรเพื่อจัดการแพ็กเกจสำหรับแพลตฟอร์ม AIX โดยใช้ installpยูทิลิตี้ เมื่อติดตั้งแพ็กเกจจากไฟล์โลคัลจะต้องเพิ่มลงในโหนดโดยใช้ไฟล์remote_file หรือ cookbook_file resources.

chef_gem

ใช้ chef_gemทรัพยากรในการติดตั้งอัญมณีสำหรับตัวอย่างของ Ruby ที่อุทิศให้กับ Chef-Client เท่านั้น เมื่อเจมถูกติดตั้งจากโลคัลไฟล์จะต้องเพิ่มไปยังโหนดโดยใช้remote_file หรือ cookbook_file ทรัพยากร

chef_gem ทรัพยากรทำงานร่วมกับคุณสมบัติและตัวเลือกเดียวกับไฟล์ gem_packageรีซอร์ส แต่ไม่ยอมรับคุณสมบัติ gem_binary เนื่องจากใช้ CurrentGemEnvironment ซึ่ง Chef-Client ทำงานอยู่เสมอ นอกเหนือจากการดำเนินการที่คล้ายกับไฟล์gem_package ทรัพยากร chef_gem ทรัพยากรทำข้างต้น

cookbook_file

ใช้ cookbook_file ทรัพยากรในการถ่ายโอนไฟล์จากไดเร็กทอรีย่อยของ COOKBOOK_NAME / files / ไปยังพา ธ ที่ระบุซึ่งอยู่บนโฮสต์ที่รัน ChefClient

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

ครอน

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

Csh

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

คำสั่งที่ดำเนินการกับรีซอร์สนี้คือ (โดยธรรมชาติ) ไม่ใช่ idempotent เนื่องจากโดยทั่วไปแล้วจะไม่ซ้ำกับสภาพแวดล้อมที่รันอยู่ ใช้ not_if และ only_if เพื่อป้องกันทรัพยากรนี้เพื่อความเป็นส่วนตัว

ปรับใช้

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

ไดเรกทอรี

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

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

dpkg_package

ใช้ dpkg_package ทรัพยากรในการจัดการแพ็คเกจสำหรับไฟล์ dpkgแพลตฟอร์ม เมื่อติดตั้งแพ็กเกจจากไฟล์โลคัลจะต้องเพิ่มลงในโหนดโดยใช้ไฟล์remote_file หรือ cookbook_file ทรัพยากร

easy_install_package

ใช้ easy_install_package ทรัพยากรในการจัดการแพ็คเกจสำหรับแพลตฟอร์ม Python

Env

ใช้ envทรัพยากรในการจัดการคีย์สภาพแวดล้อมใน Microsoft Windows หลังจากตั้งค่าคีย์สภาพแวดล้อม Microsoft Windows จะต้องเริ่มต้นใหม่ก่อนที่คีย์สภาพแวดล้อมจะพร้อมใช้งานสำหรับ Task Scheduler

erl_call

ใช้ erl_callทรัพยากรเพื่อเชื่อมต่อกับโหนดที่อยู่ภายในระบบ Erlang แบบกระจาย คำสั่งที่ดำเนินการกับรีซอร์สนี้คือ (โดยธรรมชาติ) ไม่ใช่ idempotent เนื่องจากโดยทั่วไปแล้วจะไม่ซ้ำกับสภาพแวดล้อมที่รันอยู่ ใช้ not_if และ only_if เพื่อป้องกันทรัพยากรนี้เพื่อความเป็นส่วนตัว

ดำเนินการ

ใช้ executeทรัพยากรเพื่อดำเนินการคำสั่งเดียว คำสั่งที่ดำเนินการกับรีซอร์สนี้คือ (โดยธรรมชาติ) ไม่ใช่ idempotent เนื่องจากโดยทั่วไปแล้วจะไม่ซ้ำกับสภาพแวดล้อมที่รันอยู่ ใช้not_if และ only_if เพื่อปกป้องทรัพยากรนี้เพื่อความเป็นส่วนตัว

ไฟล์

ใช้ file ทรัพยากรในการจัดการไฟล์โดยตรงบนโหนด

freebsd_package

ใช้ freebsd_package ทรัพยากรในการจัดการแพ็คเกจสำหรับแพลตฟอร์ม FreeBSD

gem_package

ใช้ gem_packageทรัพยากรในการจัดการแพ็คเกจอัญมณีที่รวมอยู่ในสูตรอาหารเท่านั้น เมื่อติดตั้งแพ็กเกจจากไฟล์โลคัลจะต้องเพิ่มลงในโหนดโดยใช้ไฟล์remote_file หรือ cookbook_file ทรัพยากร

Git

ใช้ gitทรัพยากรเพื่อจัดการทรัพยากรการควบคุมแหล่งที่มาที่มีอยู่ในที่เก็บ git ต้องใช้ git เวอร์ชัน 1.6.5 (หรือสูงกว่า) เพื่อใช้ฟังก์ชันทั้งหมดในทรัพยากร git

กลุ่ม

ใช้ group ทรัพยากรในการจัดการกลุ่มท้องถิ่น

homebrew_package

ใช้ homebrew_package ทรัพยากรในการจัดการแพ็คเกจสำหรับแพลตฟอร์ม Mac OS X

http_request

ใช้ http_requestทรัพยากรเพื่อส่งคำขอ HTTP (GET, PUT, POST, DELETE, HEAD หรือ OPTIONS) ด้วยข้อความที่กำหนดเอง ทรัพยากรนี้มักมีประโยชน์เมื่อจำเป็นต้องเรียกกลับแบบกำหนดเอง

ifconfig

ใช้ ifconfig ทรัพยากรในการจัดการอินเทอร์เฟซ

ips_package

ใช้ ips_package ทรัพยากรในการจัดการแพ็คเกจ (โดยใช้ Image Packaging System (IPS)) บนแพลตฟอร์ม Solaris 11

Ksh

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

คำสั่งที่ดำเนินการกับรีซอร์สนี้คือ (โดยธรรมชาติ) ไม่ใช่ idempotent เนื่องจากโดยทั่วไปแล้วจะไม่ซ้ำกับสภาพแวดล้อมที่รันอยู่ ใช้ not_if และ only_if เพื่อป้องกันทรัพยากรนี้เพื่อความเป็นส่วนตัว

ลิงค์

ใช้ link ทรัพยากรเพื่อสร้างลิงก์สัญลักษณ์หรือฮาร์ด

บันทึก

ใช้ logทรัพยากรเพื่อสร้างรายการบันทึก ทรัพยากรบันทึกทำงานเหมือนทรัพยากรอื่น ๆ : สร้างขึ้นในคอลเล็กชันทรัพยากรระหว่างเฟสคอมไพล์แล้วรันระหว่างเฟสการดำเนินการ (หากต้องการสร้างรายการบันทึกที่ไม่ได้ติดตั้งไว้ในคอลเล็กชันทรัพยากรให้ใช้ Chef :: Log แทนทรัพยากรบันทึก)

macports_package

ใช้ทรัพยากร macports_package เพื่อจัดการแพ็คเกจสำหรับแพลตฟอร์ม Mac OS X

Mdadm

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

หากต้องการไฟล์กำหนดค่าต้องทำโดยระบุเทมเพลตที่มีเค้าโครงอาร์เรย์ที่ถูกต้องจากนั้นใช้ตัวให้บริการการเชื่อมต่อเพื่อสร้างรายการตารางระบบไฟล์ (fstab)

เมา

ใช้ทรัพยากร mount เพื่อจัดการระบบไฟล์ที่เมาท์

Ohai

ใช้ ohaiรีซอร์สเพื่อโหลดคอนฟิกูเรชัน Ohai บนโหนดอีกครั้ง สิ่งนี้ช่วยให้สูตรอาหารที่เปลี่ยนแอตทริบิวต์ของระบบ (เช่นสูตรอาหารที่เพิ่มผู้ใช้) เพื่ออ้างถึงแอตทริบิวต์เหล่านั้นในภายหลังระหว่างการเรียกใช้ Chef-Client

แพ็คเกจ

ใช้ packageทรัพยากรในการจัดการแพ็คเกจ เมื่อติดตั้งแพ็กเกจจากไฟล์โลคัล (เช่นด้วย RubyGems, dpkg หรือ RPM Package Manager) ไฟล์จะต้องถูกเพิ่มไปยังโหนดโดยใช้รีซอร์ส remote_file หรือ cookbook_file

pacman_package

ใช้ pacman_package ทรัพยากรในการจัดการแพ็คเกจ (โดยใช้ pacman) บนแพลตฟอร์ม Arch Linux

powershell_script

ใช้ powershell_scriptทรัพยากรในการรันสคริปต์โดยใช้ตัวแปล Windows PowerShell เช่นเดียวกับวิธีการใช้สคริปต์และทรัพยากรที่ใช้สคริปต์เช่น bash, csh, perl, python และ ruby powershell_script เฉพาะสำหรับแพลตฟอร์ม Microsoft Windows และตัวแปล Windows PowerShell

Python

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

คำสั่งที่ดำเนินการกับรีซอร์สนี้คือ (โดยธรรมชาติ) ไม่ใช่ idempotent เนื่องจากโดยทั่วไปแล้วจะไม่ซ้ำกับสภาพแวดล้อมที่รันอยู่ ใช้ not_if และ only_if เพื่อป้องกันทรัพยากรนี้เพื่อความเป็นส่วนตัว

รีบูต

ใช้ rebootทรัพยากรในการรีบูตโหนดซึ่งเป็นขั้นตอนที่จำเป็นสำหรับการติดตั้งบางอย่างบนแพลตฟอร์มบางอย่าง ทรัพยากรนี้ได้รับการสนับสนุนให้ใช้กับแพลตฟอร์ม Microsoft Windows, Mac OS X และ Linux

Registry_key

ใช้ registry_key ทรัพยากรในการสร้างและลบคีย์รีจิสทรีใน Microsoft Windows

remote_directory

ใช้ remote_directoryทรัพยากรเพื่อโอนไดเร็กทอรีจากตำราอาหารไปยังโหนด ไดเร็กทอรีที่คัดลอกมาจากตำราอาหารควรอยู่ภายใต้ COOKBOOK_NAME / files / default / REMOTE_DIRECTORY

รีซอร์ส remote_directory จะเป็นไปตามความจำเพาะของไฟล์

remote_file

ใช้ remote_fileทรัพยากรเพื่อถ่ายโอนไฟล์จากตำแหน่งระยะไกลโดยใช้ความจำเพาะของไฟล์ ทรัพยากรนี้คล้ายกับทรัพยากรไฟล์

เส้นทาง

ใช้ทรัพยากรเส้นทางเพื่อจัดการตารางเส้นทางระบบในสภาพแวดล้อม Linux

rpm_package

ใช้ rpm_package ทรัพยากรในการจัดการแพ็คเกจสำหรับแพลตฟอร์ม RPM Package Manager

ทับทิม

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

คำสั่งที่ดำเนินการกับรีซอร์สนี้คือ (โดยธรรมชาติ) ไม่ใช่ idempotent เนื่องจากโดยทั่วไปแล้วจะไม่ซ้ำกับสภาพแวดล้อมที่รันอยู่ ใช้ not_if และ only_if เพื่อป้องกันทรัพยากรนี้เพื่อความเป็นส่วนตัว

ruby_block

ใช้ ruby_blockทรัพยากรในการรันโค้ด Ruby ระหว่างการรัน Chef-Client รหัส Ruby ในทรัพยากร ruby_block ได้รับการประเมินร่วมกับทรัพยากรอื่น ๆ ในระหว่างการรวมกันในขณะที่รหัส Ruby ภายนอกทรัพยากร ruby_block จะได้รับการประเมินก่อนทรัพยากรอื่น ๆ เนื่องจากมีการรวบรวมสูตร

สคริปต์

ใช้ทรัพยากรสคริปต์เพื่อดำเนินการสคริปต์โดยใช้ล่ามที่ระบุเช่น Bash, csh, Perl, Python หรือ Ruby รีซอร์สนี้อาจใช้แอ็คชันและคุณสมบัติใด ๆ ที่พร้อมใช้งานสำหรับรีซอร์สรัน

คำสั่งที่ดำเนินการกับรีซอร์สนี้คือ (โดยธรรมชาติ) ไม่ใช่ idempotent เนื่องจากโดยทั่วไปแล้วจะไม่ซ้ำกับสภาพแวดล้อมที่รันอยู่ ใช้ not_if และ only_if เพื่อป้องกันทรัพยากรนี้เพื่อความเป็นส่วนตัว

บริการ

ใช้ service ทรัพยากรในการจัดการบริการ

smart_os_package

ใช้ smartos_package ทรัพยากรในการจัดการแพ็คเกจสำหรับแพลตฟอร์ม SmartOS

solaris_package

solaris_package ทรัพยากรถูกใช้เพื่อจัดการแพ็คเกจสำหรับแพลตฟอร์ม Solaris

การโค่นล้ม

ใช้ subversion ทรัพยากรเพื่อจัดการทรัพยากรควบคุมแหล่งที่มาที่มีอยู่ในที่เก็บการโค่นล้ม

เทมเพลต

ใช้ templateทรัพยากรในการจัดการเนื้อหาของไฟล์โดยใช้เทมเพลต Embedded Ruby (ERB) โดยการถ่ายโอนไฟล์จากไดเรกทอรีย่อยของ COOKBOOK_NAME / แม่แบบ / ไปยังเส้นทางที่ระบุซึ่งอยู่บนโฮสต์ที่เรียกใช้ Chef-Client ทรัพยากรนี้รวมถึงการดำเนินการและคุณสมบัติจากทรัพยากรไฟล์ ไฟล์เทมเพลตที่จัดการโดยรีซอร์สเทมเพลตจะเป็นไปตามกฎความจำเพาะของไฟล์เช่นเดียวกับทรัพยากร remote_file และไฟล์

ผู้ใช้

ใช้ user ทรัพยากรเพื่อเพิ่มผู้ใช้อัปเดตผู้ใช้ที่มีอยู่ลบผู้ใช้และเพื่อล็อก / ปลดล็อกรหัสผ่านผู้ใช้

windows_package

ใช้ windows_package ทรัพยากรในการจัดการแพ็คเกจ Microsoft Installer Package (MSI) สำหรับแพลตฟอร์ม Microsoft Windows

windows_service

ใช้ windows_service ทรัพยากรในการจัดการบริการบนแพลตฟอร์ม Microsoft Windows

yum_package

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

Lightweight resource provider (LWRP) ให้ตัวเลือกในการขยายรายการทรัพยากรที่มีอยู่โดยการขยายคุณสมบัติและอนุญาตให้ผู้ใช้ Chef สร้างทรัพยากรที่กำหนดเอง

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

ในชุมชน Chef มีการนำทรัพยากรแบบกำหนดเองจำนวนมากมาใช้โดยใช้ LWRP ตัวอย่างการทำงานของ LWRP มีมากมายเช่นiptables_rules และ apt_repository.

วิธีการทำงาน

ตรวจสอบว่ามีชื่อตำราอาหาร Testing_resource และ run_list ของโหนดซึ่งมีตำราอาหาร Testing_resource

อาคาร LWRP

Step 1 - สร้างทรัพยากรที่กำหนดเองในตำราอาหาร Testing_resource

vipin@laptop:~/chef-repo $ subl cookbooks/Testing_resource/resources/default.rb 
actions :create, :remove 
attribute :title, kind_of: String, default: "World" 
attribute :path, kind_of: String, default: "/tmp/greeting.txt"

Step 2 - สร้างผู้ให้บริการทรัพยากรในตำราอาหาร Tesing_resource

vipin@laptop:~/chef-repo $ subl cookbooks/Testing_resource/provider/default.rb 
action :create do 
   log "Adding '#{new_resource.name}' greeting as #{new_resource. 
      path}" 
   file new_resource.path do 
      content "#{new_resource.name}, #{new_resource.title}!" 
      action :create 
end  
action :remove do 
   Chef::Log.info "Removing '#{new_resource.name}' greeting #{new_resource.path}" 
   file new_resource.path do 
      action :delete 
   end 
end

Step 3 - ใช้ทรัพยากรใหม่โดยแก้ไขสูตรเริ่มต้นของ Testing_resource

vipin@laptop:~/chef-repo $ subl cookbooks/Tesing_resource/recipes/default.rb 
greeting "Ohai" do 
   title "Chef" 
   action :create 
end

Step 4 - อัปโหลดตำราอาหารที่แก้ไขไปยังเซิร์ฟเวอร์ Chef

vipin@laptop:~/chef-repo $ knife cookbook upload greeting 
Uploading greeting [0.1.0]

Step 5 - เรียกใช้ Chef-Client บนโหนด

vipin@server:~$ sudo chef-client 
...TRUNCATED OUTPUT... 
2013-06-28T21:32:54+00:00] INFO: Processing greeting[Ohai] action 
create (greeting::default line 9) 
[2013-06-28T21:32:54+00:00] INFO: Adding 'Ohai' greeting as /tmp/ 
greeting.txt 
[2013-06-28T21:32:54+00:00] INFO: Processing file[/tmp/greeting. 
txt] action create (/srv/chef/file_store/cookbooks/greeting/ 
providers/default.rb line 7) 
[2013-06-28T21:32:54+00:00] INFO: entered create 
[2013-06-28T21:32:54+00:00] INFO: file[/tmp/greeting.txt] created 
file /tmp/greeting.txt 
...TRUNCATED OUTPUT...

Step 6 - ตรวจสอบเนื้อหาของไฟล์ที่สร้างขึ้น

user@server:~$ cat /tmp/greeting.txt 
Ohai, Chef!

สคริปต์เวิร์กโฟลว์

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

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

วิธีการ Woring

เราจำเป็นต้องติดตั้ง Python และ Git บนโหนดที่เราต้องการเรียกใช้พิมพ์เขียว

Step 1 - ติดตั้งพิมพ์เขียว

vipin@server:~$ pip install blueprint

Step 2 - สร้างพิมพ์เขียว

user@server:~$ sudo blueprint create internal-cookbook 
# [blueprint] using cached blueprintignore(5) rules 
# [blueprint] searching for Python packages 
# [blueprint] searching for PEAR/PECL packages 
# [blueprint] searching for Yum packages 
# [blueprint] searching for Ruby gems 
# [blueprint] searching for npm packages 
# [blueprint] searching for software built from source 
# [blueprint] searching for configuration files 
# [blueprint] /etc/ssl/certs/AC_Ra\xc3\xadz_Certic\xc3\ 
xa1mara_S.A..pem not UTF-8 - skipping it 
# [blueprint] /etc/ssl/certs/NetLock_Arany_=Class_Gold=_F\xc5\ 
x91tan\xc3\xbas\xc3\xadtv\xc3\xa1ny.pem not UTF-8 - skipping it 
# [blueprint] /etc/ssl/certs/EBG_Elektronik_Sertifika_Hizmet_Sa\ 
xc4\x9flay\xc4\xb1c\xc4\xb1s\xc4\xb1.pem not UTF-8 - skipping it 
# [blueprint] /etc/ssl/certs/Certinomis_-_Autorit\xc3\xa9_Racine. 
pem not UTF-8 - skipping it 
# [blueprint] /etc/ssl/certs/T\xc3\x9cB\xc4\xb0TAK_UEKAE_K\xc3\ 
xb6k_Sertifika_Hizmet_Sa\xc4\x9flay\xc4\xb1c\xc4\xb1s\xc4\xb1_-_S\ 
xc3\xbcr\xc3\xbcm_3.pem not UTF-8 - skipping it 
# [blueprint] searching for APT packages 
# [blueprint] searching for service dependencies

Step 3 - สร้างตำราอาหารจากพิมพ์เขียว

user@server:~$ blueprint show -C internal-cookbook my-server/recipes/default.rb

Step 4 - ตรวจสอบเนื้อหาของไฟล์ที่สร้างขึ้น

user@server:~$ cat internal-cookbook /recipes/default.rb 
# 
# Automatically generated by blueprint(7). Edit at your own risk. 
# 
cookbook_file('/tmp/96468fd1cc36927a027045b223c61065de6bc575.tar') 
do 
   backup false 
   group 'root' 
   mode '0644' 
   owner 'root' 
   source 'tmp/96468fd1cc36927a027045b223c61065de6bc575.tar' 
end 
execute('/tmp/96468fd1cc36927a027045b223c61065de6bc575.tar') do 
   command 'tar xf "/tmp/96468fd1cc36927a027045b223c61065de6bc575.tar"' 
   cwd '/usr/local' 
end 
directory('/etc/apt/apt.conf.d') do 
...TRUNCATED OUTPUT... 
service('ssh') do 
   action [:enable, :start] 
   subscribes :restart, resources('cookbook_file[/etc/default/ 
      keyboard]', 'cookbook_file[/etc/default/console-setup]', 
      'cookbook_file[/etc/default/ntfs-3g]', 'package[openssh-server]', 
      'execute[96468fd1cc36927a027045b223c61065de6bc575.tar]') 
end

สคริปต์เวิร์กโฟลว์

Blueprint เป็นแพ็คเกจ Python ที่ค้นหาข้อมูลการกำหนดค่าที่เกี่ยวข้องทั้งหมดของเซิร์ฟเวอร์และเก็บไว้ใน Git repo พิมพ์เขียวแต่ละตัวมีชื่อของตัวเอง

เราสามารถขอให้พิมพ์เขียวแสดงเนื้อหาของ Git repo ในรูปแบบต่างๆ

user@server:~$ ls -l internal-cookbook / 
total 8 
drwxrwxr-x 3 vagrant vagrant 4096 Jun 28 06:01 files 
-rw-rw-r-- 1 vagrant vagrant 0 Jun 28 06:01 metadata.rb 
drwxrwxr-x 2 vagrant vagrant 4096 Jun 28 06:01 recipes

พิมพ์เขียวแสดงคำสั่ง

user@server:~$ blueprint show-packages my-server 
...TRUNCATED OUTPUT... 
apt wireless-regdb 2011.04.28-1ubuntu3 
apt zlib1g-dev 1:1.2.3.4.dfsg-3ubuntu4 
python2.7 distribute 0.6.45 
python2.7 pip 1.3.1 
pip blueprint 3.4.2 
pip virtualenv 1.9.1

คำสั่งก่อนหน้านี้แสดงแพ็คเกจที่ติดตั้งทุกชนิด คำสั่งแสดงอื่น ๆ มีดังนี้ -

  • show-files
  • show-services
  • show-sources

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

การติดตั้งแพ็คเกจจาก Repo ของบุคคลที่สาม

Step 1 - แก้ไขสูตรเริ่มต้นของตำราอาหาร

vipin@laptop:~/chef-repo $ subl cookbooks/test_cookbook/recipes/default.rb 
include_recipe "apt" 
apt_repository "s3tools" do 
   uri "http://s3tools.org/repo/deb-all" 
   components ["stable/"] 
   key "http://s3tools.org/repo/deb-all/stable/s3tools.key" 
   action :add 
end 
package "s3cmd"

Step 2 - แก้ไขข้อมูลเมตาเพื่อเพิ่มการพึ่งพาในตำราอาหาร apt

vipin@laptop:~/chef-repo $ subl cookbooks/my_cookbook/metadata.rb 
... 
depends "apt"

Step 3 - อัปโหลดตำราอาหารที่แก้ไขไปยังเซิร์ฟเวอร์ Chef

Step 4 - ตรวจสอบว่าแพคเกจที่คุณพยายามติดตั้งยังไม่ได้ติดตั้ง

Step 5 - ตรวจสอบ repo เริ่มต้น

Step 6 - เรียกใช้ Chef-Client บนโหนด

Step 7 - ตรวจสอบว่าติดตั้งแพ็คเกจที่ต้องการแล้ว

การติดตั้งซอฟต์แวร์จาก Source

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

Step 1 - แก้ไขสูตรเริ่มต้น

vipin@laptop:~/chef-repo $ subl cookbooks/my_cookbook/recipes/ 
default.rb 
version = "1.3.9" 
bash "install_nginx_from_source" do 
   cwd Chef::Config['file_cache_path'] 
   code ≪-EOH 
      wget http://nginx.org/download/nginx-#{version}.tar.gz 
      tar zxf nginx-#{version}.tar.gz && 
      cd nginx-#{version} && 
      ./configure && make && make install 
   EOH

Step 2 - อัปโหลดตำราอาหารที่แก้ไขไปยังเซิร์ฟเวอร์ Chef

Step 3 - เรียกใช้ Chef-Client บนโหนด

Step 4 - ตรวจสอบว่าได้ติดตั้ง nginx แล้ว

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

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

ต่อไปนี้เป็นลิงค์ของตำราอาหารชุมชน: https://supermarket.chef.io/cookbooksdirectory