SaltStack - คู่มือฉบับย่อ

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

SaltStack คืออะไร?

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

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

โมดูล SaltStack สื่อสารกับระบบปฏิบัติการ minion ที่รองรับ Salt Masterทำงานบน Linux โดยค่าเริ่มต้น แต่ระบบปฏิบัติการใด ๆ ก็สามารถเป็นมินเนี่ยนได้และปัจจุบัน Windows, VMware vSphere และ BSD Unix ได้รับการสนับสนุนเป็นอย่างดี Salt Master และลูกน้องใช้กุญแจในการสื่อสาร เมื่อมินเนี่ยนเชื่อมต่อกับมาสเตอร์เป็นครั้งแรกมันจะเก็บคีย์ไว้ที่มาสเตอร์โดยอัตโนมัติ SaltStack ยังมีSalt SSHซึ่งให้การจัดการระบบ“ เอเจนต์น้อย”

ต้องการ SaltStack

SaltStack สร้างขึ้นเพื่อความเร็วและขนาด นี่คือเหตุผลที่ใช้ในการจัดการโครงสร้างพื้นฐานขนาดใหญ่ที่มีเซิร์ฟเวอร์นับหมื่นที่ LinkedIn, WikiMedia และ Google

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

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

คุณสมบัติของ SaltStack

SaltStack เป็นซอฟต์แวร์การจัดการการกำหนดค่าแบบโอเพนซอร์สและเครื่องมือเรียกใช้งานระยะไกล Salt เป็นเครื่องมือบรรทัดคำสั่ง ในขณะที่เขียนด้วย Python การจัดการการกำหนดค่า SaltStack เป็นภาษาที่เข้าใจง่ายและไม่ซับซ้อน แพลตฟอร์ม Salt ใช้รูปแบบการกดเพื่อดำเนินการคำสั่งผ่านโปรโตคอล SSH ระบบการกำหนดค่าเริ่มต้นคือYAML และ Jinja templates. เกลือเป็นหลักในการแข่งขันกับPuppet, Chef และ Ansible.

Salt มีคุณสมบัติมากมายเมื่อเทียบกับเครื่องมือคู่แข่งอื่น ๆ คุณลักษณะที่สำคัญบางประการเหล่านี้มีการระบุไว้ด้านล่าง

  • Fault tolerance- มินเนี่ยนเกลือสามารถเชื่อมต่อกับปรมาจารย์หลายคนพร้อมกันโดยกำหนดค่าพารามิเตอร์การกำหนดค่าหลักเป็นรายการ YAML ของปรมาจารย์ที่มีทั้งหมด ผู้เชี่ยวชาญทุกคนสามารถสั่งการไปยังโครงสร้างพื้นฐาน Salt

  • Flexible- แนวทางการจัดการทั้งหมดของ Salt มีความยืดหยุ่นมาก สามารถนำไปใช้ตามรูปแบบการจัดการระบบที่เป็นที่นิยมมากที่สุดเช่น Agent และ Server, Agent-only, Server-only หรือทั้งหมดข้างต้นในสภาพแวดล้อมเดียวกัน

  • Scalable Configuration Management - SaltStack ออกแบบมาเพื่อจัดการกับมินเนี่ยนหมื่นตัวต่อหนึ่งมาสเตอร์

  • Parallel Execution model - Salt สามารถเปิดใช้คำสั่งเพื่อเรียกใช้ระบบระยะไกลในลักษณะคู่ขนาน

  • Python API - Salt มีอินเทอร์เฟซการเขียนโปรแกรมที่เรียบง่ายและได้รับการออกแบบให้เป็นแบบแยกส่วนและขยายได้ง่ายเพื่อให้ง่ายต่อการขึ้นรูปเพื่อการใช้งานที่หลากหลาย

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

  • Language Agnostic - ไฟล์การกำหนดค่าสถานะเกลือเครื่องมือสร้างเทมเพลตหรือประเภทไฟล์รองรับภาษาทุกประเภท

ประโยชน์ของ SaltStack

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

  • Robust - Salt เป็นกรอบการจัดการการกำหนดค่าที่ทรงพลังและมีประสิทธิภาพและทำงานได้กับระบบนับหมื่น

  • Authentication - Salt จัดการคู่คีย์ SSH แบบง่ายสำหรับการตรวจสอบสิทธิ์

  • Secure - Salt จัดการข้อมูลที่ปลอดภัยโดยใช้โปรโตคอลที่เข้ารหัส

  • Fast - Salt เป็นบัสสื่อสารที่รวดเร็วและมีน้ำหนักเบาเพื่อเป็นรากฐานสำหรับเครื่องมือสั่งการระยะไกล

  • Virtual Machine Automation - ความสามารถของ Salt Virt Cloud Controller ใช้สำหรับระบบอัตโนมัติ

  • Infrastructure as data, not code - Salt นำเสนอการปรับใช้ที่เรียบง่ายการจัดการการกำหนดค่าแบบจำลองและกรอบการดำเนินการคำสั่ง

ข้อมูลเบื้องต้นเกี่ยวกับ ZeroMQ

Salt ขึ้นอยู่กับไฟล์ ZeroMQไลบรารีและเป็นไลบรารีเครือข่ายแบบฝังได้ มีน้ำหนักเบาและไลบรารีการส่งข้อความที่รวดเร็ว การใช้งานขั้นพื้นฐานอยู่ในC/C++ และการนำไปใช้งานในหลายภาษารวมถึง Java และ .Net สามารถใช้ได้.

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

ZeroMQ มาพร้อมกับห้ารูปแบบพื้นฐานดังต่อไปนี้ -

  • Synchronous Request/Response - ใช้สำหรับส่งคำขอและรับการตอบกลับในภายหลังสำหรับแต่ละรายการที่ส่งไป

  • Asynchronous Request/Response- ผู้ร้องขอเริ่มต้นการสนทนาโดยส่งข้อความร้องขอและรอข้อความตอบกลับ ผู้ให้บริการกำลังรอข้อความคำร้องที่เข้ามาและตอบกลับพร้อมกับข้อความตอบกลับ

  • Publish/Subscribe - ใช้สำหรับการกระจายข้อมูลจากกระบวนการเดียว (เช่นผู้เผยแพร่) ไปยังผู้รับหลายคน (เช่นสมาชิก)

  • Push/Pull - ใช้สำหรับการกระจายข้อมูลไปยังโหนดที่เชื่อมต่อ

  • Exclusive Pair - ใช้สำหรับเชื่อมเพื่อนสองคนเข้าด้วยกันเป็นคู่

ZeroMQ เป็นเครื่องมือเครือข่ายที่มีความยืดหยุ่นสูงสำหรับการแลกเปลี่ยนข้อความระหว่างคลัสเตอร์ระบบคลาวด์และสภาพแวดล้อมระบบอื่น ๆ ZeroMQ คือไฟล์default transport library นำเสนอใน SaltStack

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

ดูภาพประกอบต่อไปนี้ แสดงส่วนประกอบต่างๆของสถาปัตยกรรม SaltStack

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

  • SaltMinions- SaltMinion เป็นภูตทาส มินเนี่ยน Salt รับคำสั่งและการกำหนดค่าจาก SaltMaster

  • Execution- โมดูลและคำสั่ง Adhoc ดำเนินการจากบรรทัดคำสั่งกับมินเนี่ยนหนึ่งตัวขึ้นไป ทำการตรวจสอบตามเวลาจริง

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

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

  • Pillar- เสาหลักคืออินเทอร์เฟซที่สร้างและจัดเก็บข้อมูลที่มีความละเอียดอ่อนสูงเฉพาะสำหรับมินเนี่ยนโดยเฉพาะเช่นคีย์การเข้ารหัสและรหัสผ่าน จัดเก็บข้อมูลในคู่คีย์ / ค่าและข้อมูลจะได้รับการจัดการในลักษณะเดียวกับ Salt State Tree

  • Top File - จับคู่สถานะเกลือและข้อมูลเสาหลักกับมินเนี่ยน Salt

  • Runners - เป็นโมดูลที่อยู่ภายใน SaltMaster และทำหน้าที่ต่างๆเช่นสถานะงานสถานะการเชื่อมต่ออ่านข้อมูลจาก API ภายนอกค้นหามินเนี่ยนเกลือที่เชื่อมต่อและอื่น ๆ

  • Returners - ส่งคืนข้อมูลจากมิเนียนเกลือไปยังระบบอื่น

  • Reactor - มีหน้าที่กระตุ้นปฏิกิริยาเมื่อเกิดเหตุการณ์ในสภาพแวดล้อม SaltStack ของคุณ

  • SaltCloud - Salt Cloud มีอินเทอร์เฟซที่มีประสิทธิภาพในการโต้ตอบกับโฮสต์บนคลาวด์

  • SaltSSH - เรียกใช้คำสั่ง Salt ผ่าน SSH บนระบบโดยไม่ต้องใช้ Salt minion

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

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

ให้เราเข้าใจว่า SaltStack แข่งขันกับ Puppet, Chef และ Ansible เป็นหลักอย่างไร

แพลตฟอร์มและการสนับสนุน

ต่อไปนี้เป็นรายชื่อแพลตฟอร์มทั้งหมดที่รองรับ SaltStack และคู่แข่ง

  • SaltStack - ซอฟต์แวร์ SaltStack ทำงานและจัดการ Linux, Windows, Mac OS X และ UNIX หลายเวอร์ชัน

  • Puppet - Red Hat Enterprise Linux, CentOS, Oracle Linux, Scientific Linux, SUSE Linux Enterprise Server และ Ubuntu

  • Chef - Chef ได้รับการสนับสนุนในหลายแพลตฟอร์มเช่น AIX, RHEL / CentOS, FreeBSD, OS X, Solaris, Microsoft Windows และ Ubuntu

  • Ansible - Fedora แจกจ่าย Linux, CentOS และ Scientific Linux ผ่านแพ็คเกจเสริมสำหรับ Enterprise Linux (EPEL) รวมถึงระบบปฏิบัติการอื่น ๆ

ภาษาต้นทาง

  • SaltStack - Python

  • Puppet - ทับทิม

  • Chef - Ruby และ CLI ใช้ DSL ที่ใช้ทับทิม

  • Ansible - Python

ภาษาที่รองรับ

  • SaltStack - ภาษาใดก็ได้

  • Puppet - ทับทิม

  • Chef - Ruby และ CLI ใช้ DSL ที่ใช้ทับทิม

  • Ansible - ภาษาใดก็ได้

UI ของเว็บ

  • SaltStack - Web UI มีมุมมองของงานที่กำลังทำงานสถานะมิเนียนและบันทึกเหตุการณ์

  • Puppet - Web UI จัดการการรายงานสินค้าคงคลังและการจัดการโหนดแบบเรียลไทม์

  • Chef - Web UI ช่วยให้คุณค้นหาและโหนดสินค้าคงคลังดูกิจกรรมของโหนดและกำหนดตำราอาหารบทบาทและโหนด

  • Ansible - Web UI ช่วยให้คุณกำหนดค่าผู้ใช้ทีมและสินค้าคงเหลือและใช้ Playbooks กับสินค้าคงเหลือ

เครื่องมือการจัดการ

  • SaltStack - SaltStack Enterprise อยู่ในตำแหน่งที่เป็นเครื่องมือหลักในการจัดการการจัดระบบคลาวด์และการดำเนินงานด้านไอทีตลอดจน DevOps.

  • Puppet- Puppet มีสองรสชาติ Puppet Enterprise และ Open Source Puppet นอกเหนือจากการนำเสนอฟังก์ชันของ Open Source Puppet แล้ว Puppet Enterprise ยังมีเครื่องมือ GUI, API และบรรทัดคำสั่งสำหรับการจัดการโหนด

  • Chef - CFEngine เป็นเครื่องมือจัดการการกำหนดค่า

  • Ansible - Ansible 1.3 เป็นเครื่องมือหลักในการจัดการ

ประสิทธิภาพ

  • SaltStack- เกลือออกแบบมาเพื่อประสิทธิภาพสูงและความยืดหยุ่น ระบบการสื่อสารของ Salt สร้างท่อข้อมูลถาวรระหว่าง Salt master และ minions โดยใช้ ZeroMQ

  • Puppet - ปลอดภัยและมีประสิทธิภาพสูงและไม่ต้องใช้ตัวแทน

  • Chef- การต่อสู้ที่ชัดเจนที่สุดสำหรับ Chef Server คือการค้นหา การค้นหาช้าและไม่ได้รับการร้องขอจากไคลเอนต์พร้อมกัน

  • Ansible - ปลอดภัยประสิทธิภาพสูงและไม่ต้องใช้ตัวแทน

ราคาและมูลค่า

  • SaltStack- รุ่นโอเพ่นซอร์สฟรี SaltStack Enterprise มีราคา 150 เหรียญต่อเครื่องต่อปี

  • Puppet- รุ่นโอเพ่นซอร์สฟรี Puppet Enterprise มีค่าใช้จ่าย $ 100 ต่อเครื่องต่อปี

  • Chef- รุ่นโอเพ่นซอร์สฟรี Enterprise Chef ฟรี 5 เครื่อง 120 เหรียญต่อเดือนสำหรับ 20 เครื่อง 300 เหรียญต่อเดือนสำหรับ 50 เครื่อง

  • Ansible- รุ่นโอเพ่นซอร์สฟรี ตอบฟรีสำหรับ 10 เครื่องจากนั้น $ 100 หรือ $ 250 ต่อเครื่องต่อปีขึ้นอยู่กับการสนับสนุนที่คุณต้องการ

การใช้งาน

  • SaltStack- SaltStack ถูกใช้โดย Cisco และ Rackspace สามารถทำงานร่วมกับแพลตฟอร์มบนคลาวด์ใดก็ได้

  • Puppet - หุ่นถูกใช้โดย Zynga, Twitter, New York Stock Exchange, PayPal, Disney, Google และอื่น ๆ

  • Chef - Chef สามารถทำงานร่วมกับแพลตฟอร์มบนคลาวด์เช่น Internap, Amazon EC2, Google Cloud Platform, OpenStack, Microsoft Azure และ Rackspace

  • Ansible - Ansible สามารถปรับใช้กับสภาพแวดล้อมการจำลองเสมือนสภาพแวดล้อมระบบคลาวด์รวมถึง Amazon Web Services, Cloud Stack, DigitalOcean และ Google Cloud Platform เป็นต้น

ก่อนย้ายไปติดตั้งคุณต้องมีข้อกำหนดดังต่อไปนี้ -

  • เซิร์ฟเวอร์ Linux (เซิร์ฟเวอร์ Ubuntu ล่าสุด)

  • sudo หรือ root access ไปยังเซิร์ฟเวอร์นี้

ติดตั้งโปรแกรมปรับปรุงทั้งหมดโดยใช้คำสั่งต่อไปนี้ -

sudo apt-get update

ติดตั้ง SaltMaster

ติดตั้ง SaltMaster จากที่เก็บด้วยคำสั่ง apt-get ต่อไปนี้

sudo apt-get install salt-master

ติดตั้ง Salt Minion

ติดตั้ง Salt minion จากที่เก็บด้วยคำสั่ง apt-get ต่อไปนี้

sudo apt-get install salt-minion

ติดตั้ง Salt syndic

ติดตั้ง Salt syndic จากที่เก็บด้วยคำสั่ง apt-get ต่อไปนี้

sudo apt-get install salt-syndic

การกำหนดค่าหลัก

การกำหนดค่าเกลือนั้นง่ายมาก การกำหนดค่าเริ่มต้นสำหรับต้นแบบจะใช้ได้กับการติดตั้งส่วนใหญ่ ไฟล์คอนฟิกูเรชันถูกติดตั้งในไดเร็กทอรี '/ etc / salt' และตั้งชื่อตามส่วนประกอบต่างๆเช่น - / etc / salt / master และ / etc / salt / minion

#interface: 0.0.0.0
interface: <local ip address>

หลังจากอัปเดตไฟล์กำหนดค่าให้รีสตาร์ท Salt master โดยใช้คำสั่งต่อไปนี้

sudo service salt-master restart

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

การกำหนดค่า Salt Minion นั้นง่ายมาก โดยค่าเริ่มต้น Salt Minion จะพยายามเชื่อมต่อกับ DNS ชื่อ "salt"; หาก Minion สามารถแก้ไขชื่อนั้นได้อย่างถูกต้องก็ไม่จำเป็นต้องกำหนดค่าใด ๆ กำหนดคำสั่ง“ master” ใหม่ในไฟล์การกำหนดค่า minion ซึ่งโดยทั่วไปแล้ว/etc/salt/minionดังแสดงในโค้ดด้านล่าง -

#master: salt
master: <local ip address>

หลังจากอัปเดตไฟล์กำหนดค่าให้รีสตาร์ท Salt minion โดยใช้คำสั่งด้านล่าง

sudo service salt-minion restart

การจัดการที่สำคัญ

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

salt-key -L

มันจะผลิตสิ่งต่อไปนี้ output -

Accepted Keys:
Denied Keys:
Unaccepted Keys:
<local system name>
Rejected Keys:

ยอมรับคีย์ทั้งหมดโดยออกคำสั่งด้านล่าง

sudo salt-key -A

มันจะผลิตสิ่งต่อไปนี้ output -

The following keys are going to be accepted:
Unaccepted Keys:
<local system name>
Proceed? [n/Y] y
Key for minion bala-Inspiron-N4010 accepted.

ตอนนี้อีกครั้งออก salt key listing คำสั่ง

salt-key -L

มันจะผลิตสิ่งต่อไปนี้ output -

Accepted Keys:
<local system name>
Denied Keys:
Unaccepted Keys:
Rejected Keys:

การส่งคำสั่ง

การสื่อสารระหว่าง Master และ Minion ต้องได้รับการตรวจสอบโดยรันคำสั่ง test.ping

sudo salt '*' test.ping

มันจะผลิตสิ่งต่อไปนี้ output -

<local system name>
   True

ในที่นี้ '*' หมายถึงมินเนี่ยนทั้งหมด เนื่องจากเรามีมินเนี่ยนเพียงตัวเดียว - test.ping จึงเรียกใช้งานไฟล์ping คำสั่งและส่งกลับว่า ping สำเร็จหรือไม่

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

ให้เราปฏิบัติตามขั้นตอนต่อไปนี้เพื่อสร้างสภาพแวดล้อม SaltStack

ติดตั้ง VirtualBox Environment

VirtualBox เป็นแอปพลิเคชันการจำลองเสมือนข้ามแพลตฟอร์ม VirtualBox ช่วยให้คุณสามารถเรียกใช้ระบบปฏิบัติการได้มากกว่าหนึ่งระบบในแต่ละครั้ง VirtualBox ทำงานบน Windows, Linux, Macintosh และ Solaris เป็นเจ้าภาพและรองรับไฟล์Guest Operating Systems.

คุณสามารถดาวน์โหลดและติดตั้ง VirtualBox ได้โดยไปที่ลิงค์ต่อไปนี้ - https://www.virtualbox.org/wiki/Downloads

เราจะสร้างเครื่องเสมือนสามเครื่องและเรียกใช้โดยใช้ VirtualBox

ติดตั้ง Vagrant

Vagrant มอบสภาพแวดล้อมการทำงานที่ง่ายต่อการกำหนดค่าทำซ้ำและพกพาได้

คุณสามารถดาวน์โหลดและติดตั้ง Vagrant ได้โดยไปที่ลิงค์ต่อไปนี้ - https://www.vagrantup.com

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

Run Vagrant - ในการเรียกใช้ Vagrant ให้ออกคำสั่งต่อไปนี้ -

vagrant up

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

Stop Vagrant - หากต้องการหยุดการทำงานของเครื่องทั้งหมดใน VirtualBox ให้พิมพ์คำสั่งต่อไปนี้ -

vagrant halt

ดาวน์โหลด Demo Environment

SaltStack จัดเตรียมสภาพแวดล้อมการสาธิตที่เรียบง่ายเช่นการตั้งค่า Vagrant และโฮสต์อยู่ในไฟล์ github. ให้เราดาวน์โหลดการตั้งค่าโดยใช้คำสั่งต่อไปนี้ -

cd /cd/to/path

git clone https://github.com/UtahDave/salt-vagrant-demo

เริ่มสภาพแวดล้อม

ตอนนี้เริ่มสภาพแวดล้อมการสาธิตโดยใช้คำสั่งต่อไปนี้ -

cd /cd/to/path/salt-vagrant-demo
vagrant up

หลังจากคำสั่งนี้คุณจะเห็นคำตอบต่อไปนี้ -

result

ตอนนี้เซิร์ฟเวอร์สามเครื่องกำลังทำงานหนึ่งเครื่องมีการกำหนดค่าหลักเกลือและอีกสองเครื่องที่กำหนดค่ามิเนียนเกลือ

เรียกใช้ Salt master

เข้าสู่ระบบ Salt master โดยใช้คำสั่งต่อไปนี้ -

vagrant ssh master

ตอนนี้ย้ายไปยังผู้ใช้รูทโดยใช้คำสั่งด้านล่าง -

sudo su

ตอนนี้เราเชื่อมต่อกับ Salt master เรียบร้อยแล้ว

ตอนนี้ให้เราดูคำสั่งพื้นฐานบางอย่างใน SaltStack

แสดงรายการคีย์ทั้งหมด

คำสั่งต่อไปนี้คือตรวจสอบการเชื่อมต่อ Salt minion และดูว่าการเชื่อมต่อได้รับการยอมรับปฏิเสธหรือรอดำเนินการ

salt-key —list-all

มันจะผลิตสิ่งต่อไปนี้ output -

Accepted Keys:
minion1
minion2
Denied Keys:

Unaccepted Keys:
Rejected Keys:

ตรวจสอบ Salt Minions

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

salt '*' test.ping

มันจะผลิตสิ่งต่อไปนี้ output -

minion1:
   True
minion2:
   True

จากผลลัพธ์ข้างต้นให้ระบุมินเนี่ยน 1 และมินเนี่ยน 2 ซึ่งหมายความว่ามินเนี่ยนกำลังฟังอย่างถูกต้องมิฉะนั้นมินเนี่ยนอาจตอบสนองอย่างถูกต้อง

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

อินเทอร์เฟซ Salt มีสามประเภทต่อไปนี้ -

  • ระบบ ACL ของผู้เผยแพร่
  • ระบบรับรองความถูกต้องภายนอก
  • ระบบเพียร์

ให้เราเข้าใจรายละเอียดผ่านอินเทอร์เฟซเหล่านี้แต่ละรายการ

ระบบ ACL ของผู้เผยแพร่

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

publisher_acl:
   user1:
      - .*

   user2:
      - web*:
         - test.*
         - pkg.*

ที่นี่

  • user1 ได้รับอนุญาตให้ดำเนินการอะไรก็ได้

  • user2 ได้รับอนุญาตให้ใช้ test และ pkgแต่ในมินเนี่ยน“ เว็บ *” เท่านั้น

ระบบรับรองความถูกต้องภายนอก

external auth system ใช้เพื่อให้เข้าถึงเพื่อดำเนินการคำสั่ง salt กับมินเนี่ยนเฉพาะผ่านระบบการอนุญาตภายนอกเช่น PAM, LDAPฯลฯ ไฟล์คอนฟิกูเรชันนี้ถูกกำหนดไว้ในไฟล์หลักตามที่อธิบายไว้ด้านล่าง

external_auth:
   pam:
      user1:
         - 'web*':
            - test.*
            - network.*
      user2:
         - .*

ที่นี่

  • user1 ได้รับอนุญาตให้เรียกใช้ฟังก์ชันในไฟล์ test และ network modules เกี่ยวกับมินเนี่ยนที่ตรงกับ web* เป้าหมาย

  • user2 ได้รับอนุญาตให้เรียกใช้ฟังก์ชันทั้งหมด

เปิดใช้งานระบบรับรองความถูกต้องภายนอกในคำสั่ง

Salt Server มีตัวเลือก "–a" เพื่อเปิดใช้งานการตรวจสอบสิทธิ์ภายนอก

salt -a pam web\* test.ping

ที่นี่ -a pamใช้เพื่อเปิดใช้งานการตรวจสอบสิทธิ์ภายนอกของ PAM Salt Server จะขอรายละเอียดการพิสูจน์ตัวตนเมื่อใดก็ตามที่เราดำเนินการคำสั่ง ในการ จำกัด ไม่ให้ Salt Server ถามรายละเอียดการพิสูจน์ตัวตนในครั้งแรกเท่านั้นเราสามารถใช้ตัวเลือก T นี้-T option เก็บรายละเอียดการรับรองความถูกต้องสำหรับ 12 ชั่วโมงถัดไป (การตั้งค่าเริ่มต้น) และใช้เพื่อพิสูจน์ตัวตนผู้ใช้

salt -T -a pam web\* test.ping

ระบบเพียร์

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

ให้เราเข้าใจการกำหนดค่าทั้งสองนี้โดยละเอียด

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

การกำหนดค่าอย่างง่ายที่จะกำหนดในไฟล์หลักมีดังต่อไปนี้ -

peer:
   .*:
      - .*

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

ในการกำหนดมินเนี่ยนให้กับ ID เฉพาะจำเป็นต้องกำหนดคอนฟิกตามที่แสดงด้านล่าง: เพียร์ -

.*domain.com:
   - test.*

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

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

peer_run:
   .*:
      - .*

ในการกำหนดมินเนี่ยนให้กับ ID เฉพาะจำเป็นต้องกำหนดคอนฟิกตามที่ระบุด้านล่าง -

peer_run:
   .*domain.com:
      - test.*

วิธีดำเนินการคำสั่ง

เพื่อดำเนินการ test.ping กับมินเนี่ยนทั้งหมดให้ใช้ไฟล์ salt-call พร้อมกับคำสั่ง publish.publish โมดูล.

salt-call publish.publish \* test.ping

เพื่อดำเนินการ runnerใช้คำสั่ง salt-call พร้อมกับ publish.runner โมดูล.

salt-call publish.runner manage.up

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

Job ID คืออะไร?

Salt มีไดเรกทอรีแคช cachedir. ภายในนี้ไดเร็กทอรีที่มินเนี่ยนดูแลอยู่เรียกว่าไฟล์procไดเรกทอรี จะอยู่ในไดเร็กทอรี / var / cache / salt / proc ต่อไปนี้

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

โมดูล SALTUTIL

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

  • running - ส่งคืนข้อมูลงานที่กำลังทำงานอยู่ทั้งหมดที่พบในไดเร็กทอรี proc

  • find_job - ส่งคืนข้อมูลเฉพาะเกี่ยวกับงานบางอย่างตามรหัสงาน

  • signal_job - อนุญาตให้ส่งสัญญาณ id งานที่กำหนด (jid)

  • term_job - ส่งสัญญาณการยกเลิกสำหรับงานที่ระบุ

  • kill_job - ส่งสัญญาณฆ่าสำหรับงานที่ระบุ

นักวิ่งงาน

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

ฟังก์ชัน ACTIVE

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

salt-run jobs.active

ฟังก์ชัน LOOKUP_JID

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

salt-run jobs.lookup_jid <job id number>

ฟังก์ชัน LIST_JOBS

ฟังก์ชัน List_jobs ใช้เพื่อแสดงรายการข้อมูลงานสำหรับงาน แสดงโดยคำสั่งต่อไปนี้ -

salt-run jobs.list_jobs

การจัดตารางงาน

ระบบกำหนดการจะแสดงการทำงานของฟังก์ชันการดำเนินการใด ๆ กับมินเนี่ยนหรือตัววิ่งบนมาสเตอร์

ดำเนินการโดยวิธีการต่อไปนี้ -

  • Schedule - ตัวเลือกกำหนดการทั้งในหลักหรือมินเนี่ยน config ไฟล์.

  • Minion pillar data - รีเฟรชข้อมูลเสามินเนี่ยนโดยใช้คำสั่ง saltutil.refresh_pillar

  • สถานะกำหนดการหรือโมดูลกำหนดการ

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

schedule:
   job1:
      function: saltstate.sls
      seconds: 3600
      args:
         - httpd
      kwargs:
         test: True

ที่นี่ job1 จะเรียกใช้ฟังก์ชัน saltstate.sls ด้วยอาร์กิวเมนต์ที่ระบุ httpdทุกชั่วโมง test: True เป็นอาร์กิวเมนต์เพิ่มเติมสำหรับ httpd คำสั่งที่กำหนดไว้ใน saltstate.sls.

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

แบ็กเอนด์เซิร์ฟเวอร์ไฟล์

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

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

fileserver_backend:
   - git

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

fileserver_backend:
   - roots
   - git

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

ระบบไฟล์ในเครื่อง

สำหรับการใช้ระบบนี้เราจะต้องใช้รหัสต่อไปนี้

file_roots:
   base:
      - /srv/salt/prod

ระบบไฟล์ Git

สำหรับการใช้ระบบนี้เราจะต้องใช้รหัสต่อไปนี้

gitfs_remotes:
   - https://github.com/sample/sample1.git

การร้องขอไฟล์

Salt มีตัวเลือกในการร้องขอไฟล์สำหรับสภาพแวดล้อมเฉพาะ

salt://path/to/file?saltenv = base

ที่นี่สภาพแวดล้อมถูกกำหนดโดยใช้ตัวเลือกราก

การกำหนดค่าเซิร์ฟเวอร์ไฟล์

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

สิ่งแวดล้อม

สภาพแวดล้อมเริ่มต้นคือฐาน สภาพแวดล้อมนี้ถูกกำหนดและใช้เพื่อดาวน์โหลดไฟล์เมื่อไม่มีการระบุสภาพแวดล้อมอื่น

file_roots:
   base:
      - /srv/salt/base

คุณยังสามารถใช้หลายสภาพแวดล้อมดังแสดงในโค้ดด้านล่าง

file_roots:
   base:
      - /srv/salt/base
   dev:
      - /srv/salt/dev
      - /srv/salt/base

โมดูล CP

โมดูล CP เป็นโมดูลหลักในการจัดการไฟล์ Salt file server. salt-cp นอกจากนี้ยังสามารถใช้คำสั่งเพื่อแจกจ่ายไฟล์ที่นำเสนอโดยเซิร์ฟเวอร์ไฟล์ Salt

GET_FILE

cp.get_fileสามารถใช้ฟังก์ชันบน minion เพื่อดาวน์โหลดไฟล์จากต้นแบบได้ ถูกกำหนดตามที่แสดงในบล็อกรหัสต่อไปนี้

salt '*' cp.get_file salt://vimrc /etc/vimrc

คำสั่งดังกล่าวสั่งให้มินเนี่ยน Salt ทั้งหมดดาวน์โหลดไฟล์ vimrc ไฟล์และคัดลอกไปที่ /etc/vimrc.

เปิดใช้งานเทมเพลต

คุณสามารถเปิดใช้งานตัวเลือกเทมเพลตใน get_file ดังนี้ -

salt '*' cp.get_file "salt://vimrc" /etc/vimrc template = jinja

ใช้การบีบอัด

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

คำสั่งถูกกำหนดดังนี้ -

salt '*' cp.get_file salt://vimrc /etc/vimrc gzip = 5

GET_DIR

cp.get_dirสามารถใช้ฟังก์ชันบน minion เพื่อดาวน์โหลดไดเร็กทอรีทั้งหมดจากต้นแบบ ถูกกำหนดไว้ในบล็อกรหัสต่อไปนี้

salt '*' cp.get_dir salt://etc/mysql /etc

cp.get_dirรองรับการแสดงผลเทมเพลตและอาร์กิวเมนต์การบีบอัด gzip หากต้องการคุณสามารถกำหนดได้เช่นกัน

โมดูล FILECLIENT

Salt จัดเตรียมโมดูล python ที่ช่วยในการเข้าถึงเซิร์ฟเวอร์ไฟล์เกลือ salt/fileclient.py โมดูลใช้เพื่อตั้งค่าการสื่อสารจากมินเนี่ยนไปยังมาสเตอร์

โค้ดตัวอย่างในการรับไฟล์มีดังนี้ -

import salt.minion
import salt.fileclient

def get_file(path, dest, saltenv = ‘base'):
   client = salt.fileclient.get_file_client(__opts__)
   return client.get_file(path, dest, true, saltenv)

ที่นี่

  • ตัวเลือกจะพร้อมใช้งานเมื่อโมดูลทำงานในสภาวะเกลือ มิฉะนั้นเราควรระบุเส้นทางการกำหนดค่า -/etc/salt/minion.

  • path อ้างถึงเส้นทางของไฟล์ต้นฉบับในเซิร์ฟเวอร์ไฟล์เกลือ

  • dest หมายถึงเส้นทางปลายทางของไฟล์

  • saltenv หมายถึงสิ่งแวดล้อม

ในบทต่อไปเราจะเข้าใจวิธีการใช้งาน Git เป็นไฟล์เซิร์ฟเวอร์

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

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

ข้อกำหนดเบื้องต้นของ Salt Server สำหรับการใช้ Git

ข้อกำหนดขั้นต่ำสำหรับ Salt Server ในการใช้ Git เป็นไฟล์เซิร์ฟเวอร์มีดังนี้ -

  • pygit2
  • Dulwich

Pygit2 และ Dulwich ได้รับการกำหนดค่าโดยใช้ gitfs_providerพารามิเตอร์ในไฟล์ config หลัก ถ้าgitfs_provider ไม่ได้กำหนดค่าไว้ในไฟล์หลัก Salt จะชอบ pygit2 หากมีเวอร์ชันที่เหมาะสมตามด้วย GitPython และ Dulwich.

ติดตั้ง pygit2

คำสั่งต่อไปนี้ใช้เพื่อติดตั้ง pygit2 ในระบบที่ใช้ Fedora และ Ubuntu -

  • Fedora-based system

yum install python-pygit2

  • Ubuntu-based system

apt-get install python-pygit2

ที่นี่เวอร์ชันขั้นต่ำที่รองรับของ pygit2 คือ 0.20.3

ติดตั้ง GitPYTHON

GitPython สามารถติดตั้งบนต้นแบบได้อย่างง่ายดายโดยใช้ไฟล์ yum / apt command ดังแสดงด้านล่าง

  • Fedora-based system

yum install GitPython

  • Ubuntu-based system

apt-get install python-git

ติดตั้ง DULWICH

สามารถติดตั้ง Dulwich บนต้นแบบได้อย่างง่ายดายโดยใช้คำสั่ง yum

  • Fedora-based system

yum install python-dulwich

  • Ubuntu-based system

apt-get install python-dulwich

ตอนนี้เราได้ติดตั้งการอ้างอิงทั้งหมดสำหรับเซิร์ฟเวอร์ไฟล์ Git แล้ว ตอนนี้ให้เรากำหนดค่าเซิร์ฟเวอร์ไฟล์ Git นี้โดยใช้ไฟล์fileserver_backend ในส่วน master config ไฟล์.

การกำหนดค่าแบ็กเอนด์

ในการใช้ไฟล์เซิร์ฟเวอร์ Git คุณต้องเพิ่ม Git ในรายการ fileserver_backend ในไฟล์กำหนดค่าหลัก มีรายละเอียดดังนี้ -

fileserver_backend:
   - git

ให้เราทำความเข้าใจเพิ่มเติมเกี่ยวกับวิธีกำหนดค่าเซิร์ฟเวอร์ไฟล์ Git ในการกำหนดค่าระยะไกล

gitfs_remotes Configuration

คุณสามารถระบุ URL อย่างใดอย่างหนึ่งหรือทั้งหมดเช่น git: //, https: //, file: // หรือ ssh: // สำหรับการกำหนดค่า gitfs_remotes ในไฟล์หลัก ใช้เพื่อค้นหาไฟล์ที่ร้องขอ

ข้อกำหนด URL https แบบง่ายถูกกำหนดไว้ด้านล่าง

gitfs_remotes:
   - https://github.com

ssh การกำหนดค่าสามารถทำได้ดังภาพด้านล่าง

gitfs_remotes:
   - [email protected]:user1/sample.git
   - ssh://[email protected]/path/to/sample.git

ตอนนี้เราได้กำหนดค่าเซิร์ฟเวอร์ไฟล์ Git โดยใช้สองตัวเลือก fileserver_backend และ gitfs_remotes.

รีสตาร์ท Master

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

การกำหนดค่ารีโมทหลายรายการ

คำสั่งต่อไปนี้ใช้สำหรับการกำหนดค่าหลายรายการใน gitfs_remotes ในไฟล์หลัก

gitfs_remotes:
   - git://github.com/sample/sample1.git
   - https://github.com/sample/sample2.git
   - file:///root/user/sample

นี่คือที่เก็บ sample1.git, sample2.git, และ sample.doc อาจมีไฟล์ต่อไปนี้

sample1.git:
   top.sls
   
sample2.git
   edit/vimrc
   
sample.doc
   edit/vimrc

MinionFSเป็นไฟล์เซิร์ฟเวอร์พิเศษที่ Salt จัดเตรียมไว้ให้มินเนี่ยนแลกเปลี่ยนไฟล์ระหว่างกัน ไฟล์ที่ให้บริการโดย MinionFS เป็นไฟล์ที่มินเนี่ยนแชร์โดยเจตนา ในการแชร์ไฟล์ Minion ต้องทำตามขั้นตอนด้านล่างนี้

  • ซอร์สมินเนี่ยนต้องพุชไฟล์ไปยัง Salt Master โดยใช้ไฟล์ cp.push ฟังก์ชัน

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

เปิดใช้งานการส่ง

โดยค่าเริ่มต้นการผลักไฟล์โดยมินเนี่ยนไปยังต้นแบบจะถูกปิดใช้งาน ในการยอมรับไฟล์จากมินเนี่ยนมาสเตอร์จำเป็นต้องมีอ็อพชัน“ file_recv” ในไฟล์กำหนดค่าและต้องตั้งค่าเป็นTrue. โดยค่าเริ่มต้นค่าหาก“ file_recv” คือfalse.

file_recv: True

เมื่อเปิดใช้งานตัวเลือกแล้วให้เริ่มบริการหลักใหม่

การผลักดันไฟล์

มินเนี่ยนสามารถดันไฟล์ไปที่มาสเตอร์ได้ ดำเนินการโดยไฟล์cp.pushฟังก์ชัน ฟังก์ชัน cp.push นี้มีกลไกที่ง่ายในการผลักดันไฟล์โดย minion โดยใช้ minion id

salt 'minion-id' cp.push /path/to/the/file

ที่นี่ minion-id ใช้เพื่อระบุว่ามินเนี่ยนตัวใดกำลังพุชไฟล์ คำสั่งนี้จะเก็บไฟล์ไว้ในไดเร็กทอรีย่อยที่ชื่อminions ภายใต้ master's cachedir. โดยปกติเส้นทางคือ - / var / cache / salt / master / minions

สำหรับมินเนี่ยน m1 และไฟล์ - /var/log/mylog.txt ไฟล์จะถูกเก็บไว้ใน - /var/cache/salt/master/minions/m1/var/log/mylog.txt

เปิดใช้งาน MinionFS

ในการเปิดใช้งาน MinionFS เพียงแค่เพิ่ม minion ในการตั้งค่าแบ็กเอนด์ของเซิร์ฟเวอร์ไฟล์ดังที่แสดงในบล็อกโค้ดต่อไปนี้

fileserver_backend:
   - roots
   - minion

เมื่อเปิดใช้งาน MinionFS ไฟล์ที่ผลักดันมินเนี่ยนจะพร้อมใช้งานในรูปแบบ -

salt://<minion-id>/path/to/pushed/file

สำหรับมินเนี่ยน m1 และไฟล์ที่พุช - /var/log/mylog.txt ไฟล์ที่พุชจะได้รับจาก salt: //m1/var/log/mylog.txt

minionFS นี้สามารถติดตั้งในไดเร็กทอรีพิเศษโดยใช้คอนฟิกูเรชันต่อไปนี้ มันจะแยกไฟล์ minionFS ออกจากไฟล์อื่น ๆ และจะช่วยในการจัดระเบียบไฟล์ minion

minionfs_mountpoint: salt://minionfs

สำหรับการกำหนดค่าข้างต้นไฟล์จะอยู่ในส่วน minionfs ไดเรกทอรีเป็น - salt: //minionfs/m1/var/log/mylog.txt

MinionFS ตัวเลือกขั้นสูง

MinionFS ยังมีตัวเลือกในการเปิด / ปิดความพร้อมใช้งานของไฟล์ที่ผลักจากมินเนี่ยนบางตัว ตัวเลือกคือminionfs_whitelistเพื่อเปิดใช้งานมินเนี่ยนและ minionfs_blacklistเพื่อปิดการใช้งานมินเนี่ยน

minionfs_whitelist:
   - webserver
   - develop*
   - ‘mail\d+.mysite.com'

minionfs_blacklist:
   - testing

ในการกำหนดค่าข้างต้นมินเนี่ยนทั้งหมดยกเว้น testing ได้รับอนุญาตให้แชร์ไฟล์โดยใช้ minionFS

  • Webserver1

  • มินเนี่ยนที่มีรหัสตรงกับนิพจน์ทั่วไปจะพัฒนา *

  • มินเนี่ยนที่มีรหัสตรงกับนิพจน์ทั่วไป mail\d+.mysite.com.

  • Testing

ในบทต่อไปเราจะเรียนรู้วิธีใช้ Cron กับ Salt

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

Cron คืออะไร?

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

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

15 * * * * root echo "This command runs at 15 minutes past every hour"
15 10 * * * root echo "This command is run daily at 10:15 am"

ทุกบรรทัดมีจุดเข้าเจ็ดจุดดังต่อไปนี้ซึ่งคั่นด้วยช่องว่างและมีดังนี้ -

  • minute - นาทีของชั่วโมงและอยู่ระหว่าง '0' ถึง '59'

  • hour - ชั่วโมงและระบุไว้ในนาฬิกาแบบ 24 ชั่วโมง

  • day_of_month- วันของเดือนและอยู่ระหว่าง 1 และ 31 ตัวอย่างเช่น 10 วันของแต่ละเดือนคือ 10

  • month - เดือนที่ระบุและระบุเป็นตัวเลข (0-12) หรือเป็นชื่อของเดือน (เช่นพฤษภาคม)

  • day_of_week - วันในสัปดาห์ระบุเป็นตัวเลข (0-7) หรือเป็นชื่อของวัน (เช่นวันอาทิตย์)

  • user - บัญชีผู้ใช้ที่คำสั่งทำงาน

  • cmd - คำสั่งจริงและข้อโต้แย้ง

ที่นี่ * แทนที่หากไม่มีการกำหนดอะไร

Salt Caller (สายเกลือ)

Salt มี CLI (Command Line Interface) salt-callเพื่อรันโมดูลในระบบมิเนียนโลคัลแทนจากเซิร์ฟเวอร์หลักโดยใช้คำสั่ง salt Salt call CLI รองรับตัวเลือกทั้งหมดที่สนับสนุนโดยคำสั่ง salt แต่รันในเครื่อง

Salt Caller ได้รับการออกแบบมาเพื่อรองรับการดีบัก แต่ตอนนี้สามารถใช้เป็นแอปพลิเคชันแบบสแตนด์อโลนได้

salt-call test.ping

ใช้ Salt-Call ใน cron

Salt-call CLI มีประโยชน์ในการกำหนดเวลาการทำงานของเกลือโดยใช้ Cron ตัวอย่างเช่นในการตรวจสอบสถานะของมินเนี่ยนทุกวันในเวลาเที่ยงคืนเราสามารถใช้ Salt-call พร้อมกับตัวเลือก - state.apply ตามที่แสดงด้านล่าง

/etc/crontab

PATH = /bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:/opt/bin
0 0 * * * salt-call state.apply

ที่นี่

  • state.apply ฟังก์ชันจะตรวจสอบไฟล์คอนฟิกูเรชัน salt สำหรับ minion และตรวจสอบว่าการกระทำทั้งหมดที่กำหนดไว้สำหรับ minion นั้นได้รับการกำหนดค่าอย่างเหมาะสมหรือไม่

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

ในบทต่อไปเราจะเรียนรู้ Remote Execution ซึ่งเป็นแนวคิดหลักของ Salt

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

คำสั่งเกลือ

คำสั่ง Salt ช่วยให้ Salt master สามารถสื่อสารกับหนึ่งหรือมากกว่านั้นได้ Salt minions. ไวยากรณ์พื้นฐานมีดังนี้

salt '<target>' <module.function> [arguments]

ไวยากรณ์คำสั่งดังกล่าวประกอบด้วยองค์ประกอบหลักสามส่วนดังต่อไปนี้

  • target - กำหนดระบบที่ใช้โดยคำสั่ง

  • module.function- มันคือคำสั่ง คำสั่งประกอบด้วยโมดูลและฟังก์ชัน

  • arguments - ข้อมูลเพิ่มเติมที่จำเป็นสำหรับการเรียกใช้ฟังก์ชัน

ให้เราเข้าใจส่วนประกอบแต่ละอย่างโดยละเอียด

ส่วนประกอบเป้าหมายคืออะไร?

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

salt '*' test.ping

มันจะผลิตสิ่งต่อไปนี้ output -

minion2:
   True
minion1:
   True

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

เป้าหมายโดยใช้ ID (มินเนี่ยน)

คุณสามารถส่งคำสั่งไปยังมินเนี่ยนเฉพาะโดยใช้ idในเป้าหมาย แทนที่จะใช้'*'คุณสามารถแทนที่ได้โดยใช้ไฟล์ minion id. มีการกำหนดไว้ด้านล่าง

salt 'minion1’ test.ping

มันจะผลิตสิ่งต่อไปนี้ output -

minion1:
   True

เป้าหมายโดยใช้นิพจน์ทั่วไป

เป้าหมายสามารถกรองได้โดยนิพจน์ทั่วไปที่ระบุ มีการกำหนดไว้ด้านล่าง

salt -E 'minion[0-9]' test.ping

มันจะผลิตสิ่งต่อไปนี้ output -

minion2:
   True
minion1:
   True

เป้าหมายโดยใช้รายการ

สามารถระบุเป้าหมายได้อย่างชัดเจนในรายการ ถูกกำหนดไว้ในบล็อกรหัสต่อไปนี้

salt -L 'minion1,minion2' test.ping

มันจะผลิตสิ่งต่อไปนี้ output -

minion2:
   True
minion1:
   True

กำหนดเป้าหมายตามเงื่อนไข

เป้าหมายสามารถรวมกันได้ในคำสั่งเดียวดังที่แสดงในบล็อกโค้ดด้านล่าง

salt -C 'G@os:Ubuntu and minion* or [email protected].*' test.ping

มันจะผลิตสิ่งต่อไปนี้ output -

minion1:
   True
minion2:
   True

โมดูลและฟังก์ชัน (module.function)

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

คำสั่งเชลล์

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

salt '*' cmd.run 'ls -l /etc'

มันจะผลิตสิ่งต่อไปนี้ output -

minion2:
   total 868
   drwxr-xr-x 7 root root    4096 Jan 26 22:10 X11
   drwxr-xr-x 3 root root    4096 Jan 26 21:02 acpi
   -rw-r--r-- 1 root root    2981 Jan 26 20:48 adduser.conf
   -rw-r--r-- 1 root root      10 Jan 26 21:04 adjtime
   drwxr-xr-x 2 root root    4096 Jan 26 22:10 alternatives
   drwxr-xr-x 3 root root    4096 Jan 26 20:53 apm
   drwxr-xr-x 3 root root    4096 Jan 26 21:02 apparmor
   drwxr-xr-x 9 root root    4096 Jan 26 21:02 apparmor.d
   drwxr-xr-x 3 root root    4096 Jan 26 21:02 apport
   drwxr-xr-x 6 root root    4096 Jan 29 07:14 apt
   drwxr-xr-x 2 root root    4096 Jan 26 22:10 at-spi2
……………
……………
minion1:
   total 868
   drwxr-xr-x 7 root root    4096 Jan 26 22:10 X11
   drwxr-xr-x 3 root root    4096 Jan 26 21:02 acpi
   -rw-r--r-- 1 root root    2981 Jan 26 20:48 adduser.conf
   -rw-r--r-- 1 root root      10 Jan 26 21:04 adjtime
   drwxr-xr-x 2 root root    4096 Jan 26 22:10 alternatives
   drwxr-xr-x 3 root root    4096 Jan 26 20:53 apm

   drwxr-xr-x 3 root root    4096 Jan 26 21:02 apparmor
   drwxr-xr-x 9 root root    4096 Jan 26 21:02 apparmor.d
   drwxr-xr-x 3 root root    4096 Jan 26 21:02 apport
   drwxr-xr-x 6 root root    4096 Jan 29 07:09 apt
   drwxr-xr-x 2 root root    4096 Jan 26 22:10 at-spi2
   -rw-r----- 1 root daemon   144 Oct 21  2013 at.deny
   -rw-r--r-- 1 root root    2177 Apr  9  2014 bash.bashrc
   -rw-r--r-- 1 root root      45 Mar 22  2014 bash_completion
……………
……………

แสดงการใช้ดิสก์

เกลือเป็นโมดูลพิเศษ diskเพื่อรับรายละเอียดดิสก์ทั้งหมดของระบบที่ถูกจัดการ diskmodule มี usage ฟังก์ชั่นเพื่อสอบถามรายละเอียด

salt '*' disk.usage

มันจะผลิตสิ่งต่อไปนี้ output -

minion1:
   ----------
   /:
      ----------
      1K-blocks:
         41251136
      available:
         37852804
      capacity:
         5%
      filesystem:
         /dev/sda1
      used:
         1662420
   /dev:
      ----------
      1K-blocks:
         503908
      available:
         503896
      capacity:
         1%
      filesystem:
         udev
      used:
         12
   /run:
      ----------
      1K-blocks:
         101780
      available:
         101412
      capacity:
         1%
      filesystem:
         tmpfs
      used:
         368
   /run/lock:
      ----------
      1K-blocks:
         5120
      available:
         5120
      capacity:
         0%
      filesystem:
         none
      used:
         0
   /run/shm:
      ----------
      1K-blocks:
         508884
      available:
         508872
      capacity:
         1%
      filesystem:
         none
      used:
         12
   /run/user:
      ----------
      1K-blocks:
         102400
      available:
         102400
      capacity:
         0%
      filesystem:
         none
      used:
         0
   /sys/fs/cgroup:
      ----------
      1K-blocks:
         4
      available:
         4
      capacity:
         0%
      filesystem:
         none
      used:
         0
   /vagrant:
      ----------
      1K-blocks:
         303114632
      available:
         252331440
      capacity:
         17%
      filesystem:
         none
      used:
         50783192
minion2:
   ----------
   /:
      ----------
      1K-blocks:
         41251136
      available:
         37852804
      capacity:
         5%
      filesystem:
         /dev/sda1
      used:
         1662420
   /dev:
      ----------
      1K-blocks:
         503908
      available:
         503896
      capacity:
         1%
      filesystem:
         udev
      used:
         12
   /run:
      ----------
      1K-blocks:
         101780
      available:
         101412
      capacity:
         1%
      filesystem:
         tmpfs
      used:
         368
   /run/lock:
      ----------
      1K-blocks:
         5120
      available:
         5120
      capacity:
         0%
      filesystem:
         none
      used:
         0
   /run/shm:
      ----------
      1K-blocks:
         508884
      available:
         508872
      capacity:
         1%
      filesystem:
         none
      used:
         12
   /run/user:
      ----------
      1K-blocks:
         102400
      available:
         102400
      capacity:
         0%
      filesystem:
         none
      used:
            0
   /sys/fs/cgroup:
      ----------
      1K-blocks:
         4
      available:
         4
      capacity:
         0%
      filesystem:
         none
      used:
         0
   /vagrant:
      ----------
      1K-blocks:
         303114632
      available:
         252331440
      capacity:
         17%
      filesystem:
         none
      used:
         50783192

การเชื่อมต่อเครือข่าย

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

salt '*' network.interfaces

มันจะผลิตสิ่งต่อไปนี้ output -

minion1:
   ----------
   eth0:
      ----------
      hwaddr:
         08:00:27:04:3e:28
      inet:
         |_
            ----------
            address:
               10.0.2.15
            broadcast:
               10.0.2.255
            label:
               eth0
            netmask:
               255.255.255.0
      inet6:
         |_
            ----------
            address:
               fe80::a00:27ff:fe04:3e28
            prefixlen:
               64
            scope:
               link
      up:
         True
   eth1:
      ----------
      hwaddr:
         08:00:27:34:10:52
      inet:
         |_
            ----------
            address:
               192.168.50.11
            broadcast:
               192.168.50.255
            label:
               eth1
            netmask:
               255.255.255.0
      inet6:
         |_
            ----------
            address:
               fe80::a00:27ff:fe34:1052
            prefixlen:
               64
            scope:
               link
      up:
         True
   lo:
      ----------
      hwaddr:
         00:00:00:00:00:00
      inet:
         |_
            ----------
            address:
               127.0.0.1
            broadcast:
               None
            label:
               lo
            netmask:
               255.0.0.0
      inet6:
         |_
            ----------
            address:
               ::1
            prefixlen:
               128
            scope:
               host
      up:
         True
minion2:
   ----------
   eth0:
      ----------
      hwaddr:
         08:00:27:04:3e:28
      inet:
         |_
            ----------
            address:
               10.0.2.15
            broadcast:
               10.0.2.255
            label:
               eth0
            netmask:
               255.255.255.0
      inet6:
         |_
            ----------
            address:
               fe80::a00:27ff:fe04:3e28
            prefixlen:
               64
            scope:
               link
      up:
         True
   eth1:
      ----------
      hwaddr:
         08:00:27:a7:31:8e
      inet:
         |_
            ----------
            address:
               192.168.50.12
            broadcast:
               192.168.50.255
            label:
               eth1
            netmask:
               255.255.255.0
      inet6:
         |_
            ----------
            address:
               fe80::a00:27ff:fea7:318e
            prefixlen:
               64
            scope:
               link
      up:
         True
   lo:
      ----------
      hwaddr:
         00:00:00:00:00:00
      inet:
         |_
            ----------
            address:
               127.0.0.1
            broadcast:
               None
            label:
               lo
            netmask:
               255.0.0.0
      inet6:
         |_
            ----------
            address:
               ::1
            prefixlen:
               128
            scope:
               host
      up:
         True

sys.doc Execution Module

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

salt '*' sys.doc

อาร์กิวเมนต์สำหรับการเรียกใช้ฟังก์ชัน

อาร์กิวเมนต์ถูกใช้เพื่อให้ข้อมูลเพิ่มเติมสำหรับการเรียกใช้ฟังก์ชัน ตัวอย่างอาร์กิวเมนต์ง่ายๆได้รับด้านล่าง

salt '*' sys.doc pkg.install

ที่นี่อาร์กิวเมนต์ pkg.install เป็นโมดูลสำหรับติดตั้งแพ็คเกจเฉพาะ

ฟังก์ชัน Python

อาร์กิวเมนต์คือพารามิเตอร์ที่คั่นด้วยช่องว่างของฟังก์ชัน อนุญาตให้ส่งรหัส python เป็นอาร์กิวเมนต์ตามที่ระบุด้านล่าง

salt '*' cmd.exec_code python 'import sys;print sys.version'

มันจะผลิตสิ่งต่อไปนี้ output -

minion2:
   2.7.6 (default, Oct 26 2016, 20:30:19) 
   [GCC 4.8.4]
minion1:
   2.7.6 (default, Oct 26 2016, 20:30:19) 
   [GCC 4.8.4]

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

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

รัฐเกลือ

สถานะเกลือคือการกำหนดค่าที่ใช้ซ้ำได้สำหรับส่วนหนึ่งของระบบ รัฐเข้าใจง่ายกว่าและอธิบายได้โดยใช้ YAML แบบธรรมดา

สร้างรัฐเกลือ

รัฐเกลือสร้างได้ง่าย ให้เราสร้างสถานะง่ายๆในบทนี้ ย้ายไปที่ไดเร็กทอรี“ salt-vagrant-demo / saltstack / salt /” และสร้างไฟล์ชื่อsamples.sls และเพิ่มบรรทัดต่อไปนี้

samples.sls

install_network_packages:
   pkg.installed:
      - pkgs:
         - rsync
         - lftp
         - curl

ตอนนี้บันทึกไฟล์และเรียกใช้คำสั่งต่อไปนี้ใน Salt master

root@saltmaster:/home/vagrant# salt 'minion1’ state.apply samples

ที่นี่เราติดตั้ง rsync, lftp และ curl ผ่าน pkg.installed โมดูลที่ใช้สถานะเกลือในมิเนียนเกลือ minion1. หากทำงานได้อย่างถูกต้องคุณจะเห็นการตอบสนองดังที่แสดงด้านล่าง

มันจะผลิตสิ่งต่อไปนี้ output -

minion1:
----------
   ID: install_network_packages
   Function: pkg.installed
   Result: True
   Comment: All specified packages are already installed
   Started: 08:08:48.612336
   Duration: 545.385 ms
   Changes:

Summary for minion1
------------
Succeeded: 1
Failed:    0
------------
Total states run:     1
Total run time: 545.385 ms

ใช้ Salt State

ตอนนี้เราได้สร้างสถานะโดยใช้ไฟล์ ".sls" และนำไปใช้โดยการเรียกใช้โดยเฉพาะ Salt มีไฟล์สถานะเริ่มต้นที่เรียกว่าไฟล์top.slsไฟล์. ไฟล์ด้านบนใช้เพื่อใช้ไฟล์สถานะหลายไฟล์กับ Salt minions ไฟล์ด้านบนอธิบายตำแหน่งที่ควรใช้ ดี,States และ Top file ทำงานร่วมกันเพื่อสร้างแกนหลักของความสามารถในการจัดการการกำหนดค่าของ SaltStack

ตอนนี้ให้เราสร้างไฟล์ top.sls ง่ายๆในไดเร็กทอรี saltstack/salt และเพิ่มสิ่งต่อไปนี้

top.sls

base:
  '*':
      - common
   'minion1':
      - samples

ที่นี่ state, อย่างธรรมดา applies ถึง all system สถานะ, samples ใช้กับ minion1.

จากนั้นเรียกใช้ Salt master และใช้สถานะดังที่แสดงด้านล่าง

root@saltmaster:/home/vagrant# salt '*' state.apply

มันจะผลิตสิ่งต่อไปนี้ output -

minion1:
----------
   ID: common_packages
   Function: pkg.installed
   Result: True
   Comment: All specified packages are already installed
   Started: 09:33:35.642355
   Duration: 588.21 ms
   Changes:

Summary for minion1
------------
Succeeded: 1
Failed:    0
------------
Total states run:     1
Total run time: 588.210 ms
minion2:
----------
   ID: common_packages
   Function: pkg.installed
   Result: True
   Comment: All specified packages are already installed
   Started: 09:33:35.890331
   Duration: 602.79 ms
   Changes:

Summary for minion2
------------
Succeeded: 1
Failed:    0
------------
Total states run:     1
Total run time: 602.790 ms

ใช้ขนาดแบทช์

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

root@saltmaster:/home/vagrant# salt --batch-size 5 '*' state.apply

มันจะผลิตสิ่งต่อไปนี้ output -

Executing run on ['minion2', 'minion1']
jid:
   20170314094638482664
minion1:
----------
   ID: common_packages
   Function: pkg.installed
   Result: True
   Comment: All specified packages are already installed
   Started: 09:46:41.228519
   Duration: 582.24 ms
   Changes:

Summary for minion1
------------
Succeeded: 1
Failed:    0
------------
Total states run:     1
Total run time: 582.240 ms
retcode:
   0
jid:
   20170314094638482664
minion2:
----------
   ID: common_packages
   Function: pkg.installed
   Result: True
   Comment: All specified packages are already installed
   Started: 09:46:41.153609
   Duration: 605.235 ms
   Changes:

Summary for minion2
------------
Succeeded: 1
Failed:    0
------------
Total states run:     1
Total run time: 605.235 ms
retcode:
   0

ฟังก์ชั่น Salt State

ฟังก์ชัน Salt state ใช้เพื่อติดตั้งและกำหนดค่าแอปพลิเคชันบนระบบรีโมตของคุณ ให้เราติดตั้งแพ็กเกจ "Vim" โดยใช้ฟังก์ชัน Salt state

สร้างและใช้ฟังก์ชันสถานะ

สร้างไฟล์ชื่อ“ sample.sls” ภายใต้ไดเร็กทอรี“ salt-vagrant-demo / saltstack / salt / sample.sls” และเพิ่มสิ่งต่อไปนี้ -

sample.sls

install vim:
   pkg.installed:
      - name: vim

เมื่อสภาพแวดล้อม Vagrant ขึ้นให้รัน salt master และใช้ sample.sls โดยรันคำสั่งต่อไปนี้

root@saltmaster:/home/vagrant# sudo salt 'minion2’ state.apply sample

มันจะผลิตสิ่งต่อไปนี้ output -

minion2:
----------
   ID: install vim
   Function: pkg.installed
   Name: vim
   Result: True
   Comment: Package vim is installed
   Started: 15:07:45.752764
   Duration: 553.506 ms
   Changes:

Summary for minion2
------------
Succeeded: 1
Failed:    0
------------
Total states run:     1
Total run time: 553.506 ms

ตอนนี้เราได้เพิ่มแพ็กเกจ“ Vim” ตอนนี้ให้เราทดสอบแพ็คเกจโดยใช้วิธีการทดสอบเกลือ

การทดสอบสถานะเกลือ

การทดสอบจะได้รับคำสั่งโดยการเพิ่มตัวเลือก "test = True" ในสถานะ ข้อมูลการส่งคืนจะแสดงสถานะที่จะใช้เป็นสีเหลืองและผลลัพธ์จะถูกรายงานว่า 'ไม่มี'

คำสั่งต่อไปนี้ใช้เพื่อทดสอบสถานะ -

root@saltmaster:/home/vagrant# sudo salt 'minion2’ state.apply sample test = True

มันจะผลิตสิ่งต่อไปนี้ output -

minion2:
----------
   ID: install vim
   Function: pkg.installed
   Name: vim
   Result: True
   Comment: Package vim is already installed
   Started: 15:07:45.752764
   Duration: 553.506 ms
   Changes:

Summary for minion2
------------
Succeeded: 1
Failed:    0
------------
Total states run:     1
Total run time: 553.506 ms

SaltStack ─ส่วนประกอบเสา

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

ไฟล์กำหนดค่า Pillar

การกำหนดค่าสำหรับ pillar_roots ในไฟล์ config หลักดังแสดงด้านล่าง -

pillar_roots:
   base:
      - /srv/pillar

ไฟล์นี้อยู่ในไดเร็กทอรี“ / srv / เสา”

พิจารณาไฟล์บนสุดที่อยู่ใน /srv/pillar/top.sls มีโครงสร้างดังนี้ -

base:
   '*':
      - default

ตอนนี้ย้ายไปที่ไฟล์ default.sls ที่อยู่ใน /srv/pillar/default.sls และเพิ่มรหัสต่อไปนี้

# Default pillar values
apache
git

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

รีเฟรชเสา

คุณสามารถรีเฟรชเสาโดยใช้คำสั่งต่อไปนี้

root@saltmaster:/home/vagrant# salt '*' saltutil.refresh_pillar

คำสั่งดังกล่าวใช้เพื่อรีเฟรชข้อมูลเสาเกลือของมินเนี่ยนทั้งหมด

แสดงรายการข้อมูลเสา

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

root@saltmaster:/home/vagrant# salt '*' pillar.ls

มันจะผลิตสิ่งต่อไปนี้ output -

minion2:
   - apache
   - git
minion1:
   - apache
   - git

รายการเสา

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

root@saltmaster:/home/vagrant# salt '*' pillar.items

มันจะผลิตสิ่งต่อไปนี้ output -

minion2:
   ----------
   apache:
      httpd
   git:
      git
minion1:
   ----------
   apache:
      httpd
   git:
      git

SaltStack - รวมส่วนประกอบ

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

include:
   - state file 1 
   - state file 2

ที่นี่ state file 1 และ state file 2คือชื่อของไฟล์ SLS ที่คุณต้องการรวม ไม่จำเป็นต้องรวมไฟล์.slsส่วนขยาย. สถานะเกลือรวมจะถูกแทรกที่ด้านบนของไฟล์ปัจจุบัน

ไฟล์สถานะในไดเร็กทอรีย่อย

คุณสามารถรวมไฟล์สถานะไดเร็กทอรีย่อยโดยใช้จุด (.) ทำหน้าที่เป็นตัวคั่นไดเร็กทอรี

include:
   - dir.sls1

อินเทอร์เฟซ Grains

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

การกำหนดเป้าหมายธัญพืช

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

root@saltmaster:/home/vagrant# salt -G 'os:Ubuntu' test.ping

มันจะผลิตสิ่งต่อไปนี้ output -

minion1:
   True
minion2:
   True

รายชื่อธัญพืช

ธัญพืชสามารถแสดงรายการได้โดยใช้โมดูล 'grain.ls' ซึ่งกำหนดไว้ด้านล่าง

root@saltmaster:/home/vagrant# salt '*' grains.ls

รายการ

เช่นเดียวกับ Pillar ข้อมูล Grains สามารถแสดงรายการได้โดยใช้ 'grain.items'

root@saltmaster:/home/vagrant# salt '*' grains.items

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

การตั้งค่าการกำหนดค่า

ให้เราเข้าใจการตั้งค่าการกำหนดค่าต่างๆสำหรับการบันทึกโดยละเอียด

LOG_FILE

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

log_file: /var/log/salt/master

ที่นี่ไฟล์ขึ้นอยู่กับไบนารีที่ดำเนินการในต้นแบบ ในทำนองเดียวกันคุณสามารถใช้งานใน minion ได้เช่นกันซึ่งแสดงไว้ด้านล่าง

log_file: /var/log/salt/minion

คุณยังสามารถใช้ที่อยู่ระยะไกล ไวยากรณ์สำหรับการใช้ที่อยู่ระยะไกลคือ - <file | udp | tcp>: // <host | socketpath>: <port-if-required> / <log-facility>

log_file: udp://loghost:port

ที่นี่ Log-facility มีค่าเริ่มต้นเป็น LOG_USER

LOG_LEVEL

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

  • log_level: error; level value is 40 - ระบุว่าบันทึกคำสั่งบันทึกที่มีข้อผิดพลาด

  • log_level: quiet; level value is 1000 - บ่งชี้ว่าไม่ควรบันทึกสิ่งใดในระดับนี้

  • log_level: info; level value is 20 - ระบุข้อมูลบันทึกปกติ

  • log_level: warn; level value is 30 - ระบุบันทึกคำสั่งบันทึกเมื่อมีการเตือน

  • log_level: debug; level value is 10 - ข้อมูลที่เป็นประโยชน์สำหรับการดีบักทั้งการใช้เกลือและรหัสเกลือ

  • log_level: trace; level value is 5 - ข้อมูลการดีบักโค้ดโดยละเอียดเพิ่มเติม

LOG_LEVEL_LOGFILE

กำหนดระดับของข้อความที่จะส่งไปยังล็อกไฟล์

log_level_logfile: info

LOG_DATEFMT

กำหนดรูปแบบวันที่บันทึก โดยค่าเริ่มต้นจะแสดงเป็น% Y-% m-% d% H:% M:% S

log_datefmt_logfile: '%Y-%m-%d %H:%M:%S'

LOG_FMT_CONSOLE

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

'%(colorlevel)s'       # log level name colorized by level
'%(colorname)s'        # colorized module name
'%(colorprocess)s'     # colorized process number
'%(colormsg)s'         # colorized messages name

LOG_FMT_LOGFILE

เป็นการกำหนดรูปแบบของไฟล์บันทึกที่บันทึกข้อความ ไวยากรณ์พื้นฐานมีดังนี้ -

%(asctime)s,%(msecs)03d [%(name)-17s][%(levelname)-8s] %(message)s

LOG_GRANULAR_LEVELS

ระดับนี้ใช้เพื่อควบคุมระดับการบันทึกโดยเฉพาะมากขึ้น

log_granular_levels:
   'salt': 'info'
   'salt.modules': ‘trace'

ที่นี่ไลบรารีเกลือหลักที่ระดับ 'ข้อมูล' จะตั้งค่าไฟล์ salt.modules เพื่อบันทึกที่ระดับการติดตาม

ตัวจัดการบันทึกภายนอก

Salt ใช้ตัวจัดการบันทึกภายนอก LogStash และ Sentry สำหรับการบันทึก ให้เราเข้าใจโดยละเอียดในบทนี้

ตัวจัดการ LOGSTASH

LogStash เป็นโอเพ่นซอร์ส ไปป์ไลน์การประมวลผลข้อมูลที่ปลอดภัยฝั่งเซิร์ฟเวอร์ ให้เราพิจารณาตัวจัดการการบันทึก UDP แบบง่ายๆใน Salt ที่ใช้ LogStash

ระบุการเปลี่ยนแปลงต่อไปนี้ในไฟล์ Salt master -

logstash_udp_handler:
   host: 127.0.0.1
   port: 9999
   version: 1
   msg_type: logstash

จากนั้นเพิ่มการเปลี่ยนแปลงในไฟล์กำหนดค่า Logstash -

input {
   udp {
      port ⇒ 9999
      codec ⇒ json
   }
}

ที่นี่ UDP - คืออินพุตที่ต้องมีรูปแบบเป็น json_eventซึ่งเป็นสิ่งที่เราส่งผ่านสาย

SENTRY Logging Handler

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

sentry_handler:
   dsn: https://pub-key:[email protected]/app-id
   log_level: debug

ที่นี่ระดับการบันทึกเริ่มต้นสำหรับตัวจัดการยามคือ ERROR แต่เรากำหนดการดีบัก log_level ภายใต้คีย์การกำหนดค่า sentry_handler

Salt ดำเนินการคำสั่งในระบบระยะไกลโดยใช้ salt-minion. นี่คือพฤติกรรมปกติ ในบางสถานการณ์ระบบรีโมตสามารถเข้าถึงได้โดยโปรโตคอล SSH เท่านั้น สำหรับสถานการณ์เหล่านี้ Salt มีตัวเลือกในการเชื่อมต่อระบบระยะไกลโดยใช้โปรโตคอล SSH เท่านั้นและดำเนินการคำสั่งผ่านเลเยอร์ SSH

Salt SSHง่ายมากในการกำหนดค่า การกำหนดค่าที่จำเป็นเพียงอย่างเดียวคือการระบุรายละเอียดระบบระยะไกลในไฟล์พิเศษที่เรียกว่าRoster file. โดยปกติไฟล์บัญชีรายชื่อนี้จะอยู่ใน/etc/salt/roster. ไฟล์บัญชีรายชื่อจะมีข้อมูลทั้งหมดเกี่ยวกับระบบระยะไกลและเราจะเชื่อมต่อกับมันได้อย่างไร เมื่อกำหนดค่าไฟล์บัญชีรายชื่อแล้วคำสั่ง Salt ทั้งหมดจะดำเนินการโดยใช้ไฟล์salt-ssh แทนคำสั่งเกลือ

ไฟล์บัญชีรายชื่อ

ระบบบัญชีรายชื่อได้รับการออกแบบมาโดยเฉพาะสำหรับ Salt SSH สิ่งนี้ได้รับการออกแบบให้เป็นระบบที่เสียบปลั๊กได้ จุดประสงค์เดียวของระบบบัญชีรายชื่อคือการรวบรวมข้อมูลเกี่ยวกับระบบระยะไกล ไฟล์บัญชีรายชื่อคือไฟล์YAML based configuration file มีข้อมูลระบบระยะไกลเป็น targets. เป้าหมายเหล่านี้เป็นโครงสร้างข้อมูลพิเศษที่มีชุดแอตทริบิวต์ที่กำหนดไว้ล่วงหน้า ไฟล์บัญชีรายชื่อมีเป้าหมายตั้งแต่หนึ่งรายการขึ้นไปและแต่ละเป้าหมายจะถูกระบุโดยไฟล์Salt ID.

โครงสร้างพื้นฐานของไฟล์บัญชีรายชื่อมีดังนี้ -

<Salt ID>:
   host: <host name>
   user: <user name>
   passwd: <password of the user>

แอตทริบิวต์อื่น ๆ ทั้งหมดที่สนับสนุนโดยไฟล์บัญชีรายชื่อเป็นทางเลือก มีดังนี้ -

  • port - หมายเลขพอร์ต SSH

  • sudo - ไม่ว่าจะเรียกใช้คำสั่งผ่าน sudo

  • sudo_user - ชื่อผู้ใช้ sudo

  • tty - จริงถ้าเปิดใช้งาน sudo

  • priv - คีย์ส่วนตัว

  • timeout - หมดเวลาสำหรับการเชื่อมต่อ SSH

  • minion_opts - พจนานุกรมของ minion ตัวเลือก

  • thin_dir - ไดเร็กทอรีหน่วยเก็บข้อมูลของระบบเป้าหมายสำหรับส่วนประกอบเกลือ

  • cmd_umask - umask เพื่อบังคับสำหรับคำสั่ง salt-call

ไฟล์บัญชีรายชื่อตัวอย่างมีดังนี้ -

web:
   host: 192.168.2.1
   user: webuser
   passwd: secret
   sudo: True   
db:
   host: 192.168.2.2

ปรับใช้คีย์ SSH

Salt SSH จะสร้างคู่คีย์สาธารณะ / ส่วนตัวเริ่มต้นสำหรับการเข้าสู่ระบบ SSH เส้นทางเริ่มต้นจะเป็น /etc/salt/pki/master/ssh/salt-ssh.rsa คีย์นี้สามารถปรับใช้กับระบบรีโมตโดยใช้ssh-copy-id คำสั่งดังที่แสดงด้านล่าง

ssh-copy-id -i /etc/salt/pki/master/ssh/salt-ssh.rsa.pub [email protected]

ดำเนินการคำสั่ง

การดำเนินการคำสั่ง salt ทำได้ง่ายเพียงแค่เปลี่ยนไฟล์ salt cli สั่งเป็น salt-ssh ดังแสดงด้านล่าง

salt-ssh '*' test.ping

คำสั่งเชลล์ดิบ

Salt SSH มีอ็อพชัน (-r) เพื่อดำเนินการคำสั่ง raw ในระบบรีโมตโดยข้ามโมดูลและฟังก์ชันของเกลือ

salt-ssh '*' -r 'ls'

กำหนดเป้าหมายด้วย Salt SSH

การกำหนดเป้าหมายระบบระยะไกลใน Salt SSH รองรับเฉพาะเป้าหมาย glob และ regex เนื่องจาก Salt SSH เป็นโมดูลแยกต่างหากจึงมีตัวเลือกที่ จำกัด เท่านั้น ณ ตอนนี้และจะให้คุณสมบัติเพิ่มเติมในอนาคตอันใกล้

เกลือมีโมดูลแยกต่างหาก Salt Cloud เพื่อจัดหาเครื่องเสมือนของผู้ให้บริการคลาวด์ต่างๆเช่น Amazon AWS, Google Compute เป็นต้น Salt Cloud เป็นอินเทอร์เฟซทั่วไปสำหรับกำหนดค่าและจัดการ VM ของผู้ให้บริการคลาวด์ต่างๆ

  • Cloud Config- ไฟล์คอนฟิกูเรชันหลักสำหรับ Salt Cloud คือ / etc / salt / cloud และใช้กับ VM ทั้งหมด ไฟล์คอนฟิกูเรชันหลักเรียกว่าCloud Config.

  • Cloud Providers - ในการกำหนดเป้าหมายผู้ให้บริการระบบคลาวด์ที่เฉพาะเจาะจงเราสามารถใช้ไฟล์การกำหนดค่าเฉพาะและอยู่ใน /etc/salt/cloud.providers.d/*.conf สิ่งเหล่านี้เรียกว่า Cloud Providers.

  • Cloud Profiles - ในการกำหนดเป้าหมาย VM เฉพาะเรายังสามารถใช้ไฟล์การกำหนดค่าพิเศษซึ่งใช้กับ VM นั้น ๆ เท่านั้นและอยู่ที่ /etc/salt/cloud.profiles.d/*.conf ซึ่งจะเรียกว่า Cloud Profiles.

สำหรับเครื่องเสมือนการตั้งค่าในไฟล์ Cloud Config ถูกนำไปใช้ก่อนจากนั้นในไฟล์ Cloud Providers และในที่สุดการแทนที่ก็ทำได้โดย Cloud Profiles.

การติดตั้ง Salt Cloud

โดยค่าเริ่มต้น Salt Cloud ถูกสร้างขึ้นใน Salt และพร้อมใช้งาน หากไม่สามารถใช้งานได้เราสามารถติดตั้งได้โดยใช้คำสั่งด้านล่าง

pip install salt-cloud

เนื่องจาก Salt Cloud เป็นโมดูลแยกต่างหากและทำงานในกระบวนการของตัวเองจึงสามารถติดตั้งในระบบ Salt Minion ได้เช่นกันแทน Salt Master

การจัดเตรียมเครื่องเสมือน

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

ผู้ให้บริการระบบคลาวด์

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

  • สร้างไฟล์ my-amazon-cloud.conf ภายใต้ /etc/salt/cloud.providers.d/

  • เพิ่มผู้ให้บริการใหม่โดยใช้ไฟล์ ec2 คนขับ.

my-amazon-cloud:
   driver: ec2
   id: '<AWS_ID>'
   key: '<AWS_KEY>'
   private_key: /path/to/privatekey.pem
   keyname: <name of the key>
   securitygroup: default

   minion:
      master: <master server>

Salt จัดเตรียมไดรเวอร์สำหรับโฮสต์บนคลาวด์ที่หลากหลายเช่น GoGrid, HP Cloud, Google Compute Engine (GCE), Amazon AWS, Joyent, Linode, OpenNebula, ProfitBricks, Proxmox, Saltify, VexxHost, VMWare เป็นต้น

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

salt-cloud --list-location my-amazon-cloud
salt-cloud --list-images my-amazon-cloud
salt-cloud --list-sizes my-amazon-cloud

โปรไฟล์คลาวด์

โปรไฟล์ Cloud ระบุอิมเมจและขนาดเครื่องเสมือน สามารถกำหนดค่าได้ภายใต้ - /etc/salt/cloud.profiles.d/ ให้เราสร้างโปรไฟล์ง่ายๆsimple.conf.

aws_micro:
   provider: my-amazon-cloud
   image: <image_id>
   size: <machine_id e.g. t1.micro>

เครื่องเสมือน

เมื่อกำหนดค่าผู้ให้บริการและโปรไฟล์แล้วเราสามารถจัดหาเครื่องเสมือนได้อย่างง่ายดายโดยใช้ Salt-cloud ดังที่แสดงด้านล่าง

salt-cloud -p aws_micro master minion1 minion2

ที่ไหน p - Profile name master, minion1 และ minion2 เป็นเครื่องเสมือนใหม่

รายละเอียดของเครื่องเสมือนที่สร้างขึ้นใหม่สามารถรับได้โดยใช้คำสั่งต่อไปนี้

salt-cloud --query

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

slat-cloud -d master minion1

แผนที่เมฆ

Cloud Map เป็นรูปแบบพิเศษในการสร้างเครื่องเสมือนหลายเครื่องพร้อมกัน รูปแบบของไฟล์แผนที่คือการระบุโปรไฟล์จากนั้นเพิ่มรายชื่อเครื่องเสมือนที่อยู่ด้านล่าง

ไฟล์แผนที่ตัวอย่างมีดังนี้ -

micro:
   - web1
   - web2
large:
   - db1
   - db2

ไฟล์แผนที่สามารถส่งผ่านเป็นอาร์กิวเมนต์ไปยังคำสั่ง salt-cloud เพื่อสร้างเครื่องเสมือนดังต่อไปนี้ -

salt-cloud -m /path/to/mapfile

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

Salt มีโมดูลแยกต่างหากมิเนียนพร็อกซีเกลือที่ควบคุมระบบระยะไกลโดยใช้บริการ REST ที่ทำงานในระบบรีโมต บริการ REST นี้เป็นบริการเว็บที่ใช้ HTTP ที่เขียนโดยใช้ไฟล์Representational State Transfer (REST) แนวคิดและทั้งสองใช้งานง่ายและง่ายต่อการบริโภค

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

เมื่อบริการเว็บ REST ได้รับการพัฒนาและปรับใช้ในระบบระยะไกลแล้ว Salt สามารถกำหนดค่าให้ควบคุมอุปกรณ์ระยะไกลโดยใช้บริการเว็บ REST แทนมินเนี่ยนเกลือ

ตัวอย่างการทำงาน

ให้เราเรียนรู้แนวคิดของ salt proxy minionใช้สภาพแวดล้อมการทำงานแบบสด สำหรับสภาพแวดล้อมที่ใช้งานจริงเราเลือกระบบ Linux สำหรับทั้ง master และ proxy minion เราจะควบคุมระบบโดยใช้ REST web service แทน salt-minion

ติดตั้งและกำหนดค่า REST Web Service

Salt ให้ตัวอย่างการใช้งานบริการเว็บ REST ซึ่งตั้งชื่อเป็น proxyminion_rest_example ในโมดูลการสนับสนุน ให้เราติดตั้งบริการเว็บตัวอย่าง

  • ติดตั้ง ‘bottle’ใช้ pip bottle คำสั่งคือเฟรมเวิร์กเว็บ python สำหรับพัฒนาเว็บแอปพลิเคชัน

pip install bottle = 0.12.8

  • ดาวน์โหลดไฟล์ saltstack/salt-contribโครงการจาก github มิฉะนั้นโคลนโครงการโดยใช้คำสั่งต่อไปนี้

git clone https://github.com/saltstack/salt-contrib

  • เปิดเทอร์มินัลแล้วไปที่ไฟล์ salt-contrib ไดเรกทอรี

  • ไดเร็กทอรี salt-Contrib นี้จะมีโฟลเดอร์ proxyminion_rest_example. โฟลเดอร์นี้มีตัวอย่างการใช้งานสำหรับบริการเว็บ REST ไปที่โฟลเดอร์ proxyminion_rest_example

  • รันคำสั่งต่อไปนี้เพื่อเริ่มบริการเว็บ REST

python rest.py --address <your ip address> --port 8000

  • เปิดเบราว์เซอร์และโหลด http: // «ที่อยู่ IP ของคุณ»: 8000 ซึ่งจะแสดงหน้าเริ่มต้นพร้อมบริการและแพ็คเกจดังที่แสดงในภาพหน้าจอด้านล่าง

ตอนนี้เราได้กำหนดค่าบริการเว็บ REST แล้วและจะตรวจสอบวิธีกำหนดค่าพร็อกซีเกลือเพื่อค้นหาบริการเว็บ REST และควบคุมระบบ

กำหนดค่า Salt-Proxy

ในการกำหนดค่า Salt-Proxy เราต้องทำตามขั้นตอนด้านล่าง

  • เราต้องระบุโหนดหลักสำหรับ salt-proxy แก้ไขตำแหน่งไฟล์การกำหนดค่าพร็อกซีซึ่งอยู่ใน / etc / salt / proxy และป้อนรหัสต่อไปนี้

master: <your ip address>

  • แก้ไข / สร้างไฟล์เสาหลักใน /srv/pillar/top.sls ดังแสดงในบล็อกรหัสต่อไปนี้

base:
  'p8000':
      - p8000

  • เพิ่มไฟล์เสาใหม่ p8000.sls ใน /srv/pillar ดังที่แสดงในบล็อกโค้ดด้านล่าง

proxy:
   proxytype: rest_sample
   url: http://<your ip address>:8000

  • เริ่ม salt-proxy ในโหมด debug โดยใช้คำสั่งต่อไปนี้

salt-proxy --proxyid = p8000 -l debug

  • เช่นเดียวกับเกลือ - มินเนี่ยนให้ยอมรับ salt-proxy key ดังแสดงด้านล่าง

salt-key -y -a p8000

The following keys are going to be accepted:
Unaccepted Keys:
p8000
Key for minion p8000 accepted.

วิ่งเกลือ

ตอนนี้เรียกใช้ salt คำสั่งและเรียกไฟล์ ping.test ฟังก์ชันดังแสดงด้านล่าง

salt p8000 test.ping

เราสามารถเรียกใช้ฟังก์ชันใด ๆ ที่สนับสนุนโดยบริการเว็บ REST โดยใช้ saltซึ่งคล้ายกับ salt-minion.

ตัวอย่างเช่นข้อมูลเกรนสามารถรับได้โดยใช้คำสั่งต่อไปนี้

salt p8000 grains.items

ระบบอีเวนต์ใน Salt เป็นอินเทอร์เฟซ ZeroMQ PUB ในพื้นที่ซึ่งยิงเหตุการณ์ที่เป็นเกลือ ดำเนินการโดยส่วนประกอบต่อไปนี้

  • Event Sockets - ใช้เพื่อเผยแพร่กิจกรรม

  • Event library - ใช้เพื่อฟังเหตุการณ์และส่งเหตุการณ์เข้าสู่ระบบเกลือ

กิจกรรม Salt Master

ผู้เชี่ยวชาญด้านเกลือจัดเตรียมเหตุการณ์ประเภทต่างๆซึ่งมีรายละเอียดอธิบายไว้ด้านล่าง -

  • เหตุการณ์การพิสูจน์ตัวตน
  • เริ่มกิจกรรม
  • เหตุการณ์สำคัญ
  • งานอีเว้นท์
  • กิจกรรมนักวิ่ง
  • เหตุการณ์การแสดงตน
  • เหตุการณ์บนคลาวด์

ให้เราดูรายละเอียดของเหตุการณ์แต่ละประเภท

เหตุการณ์การพิสูจน์ตัวตน

เหตุการณ์การพิสูจน์ตัวตนเหล่านี้เริ่มทำงานเมื่อมินเนี่ยนทำการตรวจสอบการพิสูจน์ตัวตนกับมาสเตอร์ แสดงโดย salt / auth

เริ่มกิจกรรม

เหตุการณ์เริ่มต้นจะเริ่มขึ้นเมื่อใดก็ตามที่มินเนี่ยนเชื่อมต่อกับซอลท์มาสเตอร์และมันจะแสดงด้วย salt / minion // start

เหตุการณ์สำคัญ

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

กิจกรรมงาน

เหตุการณ์งานจะถูกไล่ออกทุกครั้งที่งานใหม่กำลังจะเริ่มขึ้น มันแสดงโดยsalt/job//new. ที่นี่ JID - Job id new - new job

กิจกรรมนักวิ่ง

เมื่อนักวิ่งเริ่มดำเนินการเหตุการณ์นักวิ่งจะเริ่มขึ้น แสดงโดย salt / run // new

เหตุการณ์การแสดงตน

เมื่อมินเนี่ยนเชื่อมต่อหรือเชื่อมต่อใหม่หรือตัดการเชื่อมต่อเหตุการณ์นี้จะเริ่มทำงานในช่วงเวลาปกติ แสดงโดย -salt/presence/present และ salt/presence/change. ที่นี่

  • Present - หมายถึง Salt master เชื่อมต่อกับรายชื่อมินเนี่ยน

  • Change - ใช้ตรวจจับมินเนี่ยนตัวใหม่ - เชื่อมต่อหรือตัดการเชื่อมต่อ

เหตุการณ์บนคลาวด์

เหตุการณ์ Salt-Cloud ถูกยิงบนเครื่องเสมือน มินเนี่ยนจะไม่ดำเนินการ คุณสามารถเข้าถึงได้โดยใช้ -salt/cloud//creating. จะเริ่มทำงานเมื่อ Salt cloud เริ่มกระบวนการเรียกใช้เครื่องเสมือน

เครื่องมือเหตุการณ์

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

salt-run state.event pretty = True

ที่นี่รันเนอร์ได้รับการออกแบบมาเพื่อโต้ตอบกับบัสเหตุการณ์จากเครื่องมือภายนอกและเชลล์สคริปต์ รถบัสเหตุการณ์ของ Salt สามารถเข้าถึงได้จากระยะไกลผ่านทางREST API. แสดงโดย - (URL ตัวอย่าง)

curl -SsNk https://salt-api.example.com:8000/events?token = 05A3.

ในทำนองเดียวกันคุณสามารถเข้าถึงเหตุการณ์จากสคริปต์ Python ได้เช่นกัน

โดยทั่วไปแล้ว orchestrationคือการประสานงานและการจัดระบบอัตโนมัติ Orchestrate Runner ใช้เพื่อทำการออเคสตร้าใน SaltStack

Orchestrate Runner

เขา Orchestrate Runner นำเสนอฟังก์ชันทั้งหมดของ OverState(ระบบก่อนหน้า) เดิมเรียกว่าstate.slsนักวิ่ง. นักวิ่งออเคสเตรตนี้ใช้เพื่อสรุประบบ Salt state ให้เป็นบริบทของ Salt master

state.sls และ state.highstate ฟังก์ชั่นจะถูกเรียกใช้งานกับ Salt minion แต่ละตัว แต่ไฟล์ state.orchestrateนักวิ่งจะถูกดำเนินการบนต้นแบบ state.orchestrateนักวิ่งช่วยให้คุณสามารถจัดการโครงสร้างพื้นฐานทั้งหมดของคุณได้อย่างสมบูรณ์ ให้เราเข้าใจวิธีดำเนินการตามขั้นตอนง่ายๆ

การดำเนินการอย่างง่าย

คำสั่ง Orchestrate Runner เหมือนกับคำสั่ง state.sls แต่คุณสามารถใช้งานได้โดยใช้ "salt-run" แทนการใช้เกลือ

สมมติว่าคุณมีไฟล์ sample.sls ไฟล์อยู่ที่ /srv/salt/orch/samples.sls. เพิ่มรหัสต่อไปนี้ในไฟล์นั้น

sample.sls

install_nginx:
   salt.state:
      - tgt: 'web*'
      - sls:
         - nginx

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

salt-run state.orchestrate orch.sample

มันจะผลิตสิ่งต่อไปนี้ output -

saltmaster.local_master:
----------
   ID: install_nginx
   Function: salt.state
   Result: True
   Comment: States ran successfully.
   Started: 11:54:56.308078
   Duration: 63.401 ms
   Changes:

Summary for saltmaster.local_master
------------
Succeeded: 1
Failed:    0
------------
Total states run:     1
Total run time:  63.401 ms
root@saltmaster:/home/vagrant#

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

เรียกใช้ฟังก์ชัน

ในการเรียกใช้ฟังก์ชันคุณควรใช้ไฟล์ salt.function. พิจารณาไฟล์data.sls ตั้งอยู่ที่ /srv/salt/orch/data.sls. ตอนนี้เพิ่มการเปลี่ยนแปลงต่อไปนี้ในไฟล์นั้น

data.sls

cmd.run:
   salt.function:
      - tgt: '*'
      - arg:
         - rm -rf /tmp/data

คำสั่งต่อไปนี้ใช้เพื่อเรียกใช้ฟังก์ชัน Salt

root@saltmaster:/home/vagrant# salt-run state.orchestrate orch.data

มันจะผลิตสิ่งต่อไปนี้ output -

saltmaster.local_master:
----------
   ID: cmd.run
   Function: salt.function
   Result: True
   Comment: Function ran successfully. Function cmd.run ran on minion1, minion2.
   Started: 12:14:54.791635
   Duration: 234.615 ms
   Changes:
      minion1:

      minion2:
Summary for saltmaster.local_master
------------
Succeeded: 1 (changed = 1)
Failed:    0
------------
Total states run:     1
Total run time: 234.615 ms

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

หลังจากสร้างแพ็กเกจสูตรแล้วจะถูกคัดลอกไปยัง Repository System เพื่อให้ใช้สำหรับ Salt Masters ก่อนที่จะย้ายไปที่ตัวจัดการแพ็คเกจให้เราดูวิธีการติดตั้งแพ็คเกจ“ nginx” โดยใช้คำสั่ง Salt basic

ไวยากรณ์ต่อไปนี้ใช้เพื่อติดตั้งแพ็กเกจ“ nginx”

root@saltmaster:/home/vagrant# salt '*' pkg.install nginx

ที่นี่ pkg.install nginxคำสั่งใช้เพื่อติดตั้งแพ็คเกจ หลังจากดำเนินการคุณจะเห็นคำตอบต่อไปนี้

มันจะผลิตสิ่งต่อไปนี้ output -

minion2:
   ----------
   httpd:
      ----------
      new:
         1
      old:
   httpd-cgi:
      ----------
      new:
         1
      old:
   libxslt1.1:
      ----------
      new:
         1.1.28-2build1
      old:
   nginx:
      ----------
      new:
         1.4.6-1ubuntu3.7
      old:
   nginx-common:
      ----------
      new:
         1.4.6-1ubuntu3.7
      old:
   nginx-core:
      ----------
      new:
         1.4.6-1ubuntu3.7
      old:
minion1:
   ----------
   httpd:
      ----------
      new:
         1
      old:
   httpd-cgi:
      ----------
      new:
         1
      old:
   libxslt1.1:
      ----------
      new:
         1.1.28-2build1
      old:
   nginx:
      ----------
      new:
         1.4.6-1ubuntu3.7
      old:
   nginx-common:
      ----------
      new:
         1.4.6-1ubuntu3.7
      old:
   nginx-core:
      ----------
      new:
         1.4.6-1ubuntu3.7
      old:

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

root@saltmaster:/home/vagrant# salt '*' service.start nginx

หลังจากรันคำสั่งนี้ผลลัพธ์จะมีลักษณะดังที่แสดงในบล็อกโค้ดด้านล่าง

minion1:
   True
minion2:
   True

ดังนั้นเราจึงได้ติดตั้งและเริ่มบริการสำหรับแพ็คเกจ“ nginx” โดยใช้คำสั่งพื้นฐาน ตอนนี้ให้เราพูดถึงวิธีการสร้างและติดตั้งแพ็คเกจใน Salt package manager

แพ็คเกจอาคาร

สามารถสร้างแพ็คเกจบนระบบใดก็ได้ที่คุณสามารถติดตั้ง Salt แพคเกจมีสามประเภทดังนี้

  • Formula
  • Reactor
  • Conf

ตอนนี้ให้เราเข้าใจวิธีสร้างแพ็คเกจโดยใช้ไฟล์ Fomula ไฟล์.

ไฟล์สูตร

ไฟล์ส่วนใหญ่จากแพ็กเกจจะอยู่ที่ไดเร็กทอรี - / srv / spm / salt / โดยดีฟอลต์ แต่ไฟล์เสาหลักสามารถวางไว้ในไดเร็กทอรี - / srv / spm / Pillars / ไฟล์สูตรอธิบายแพ็คเกจ

Example

name: apache
os: RedHat
os_family: RedHat
version: 201607
release: 2
summary: Formula for installing Apache
description: Formula for installing Apache

ที่นี่

  • Name- ชื่อแพ็กเกจ ชื่อแพ็กเกจคือapache.

  • os - ใช้เพื่อทราบว่าระบบปฏิบัติการใดสามารถรองรับแพ็คเกจนี้ได้

  • os_family - ใช้เพื่อทราบว่าตระกูลระบบปฏิบัติการใดที่สามารถรองรับแพ็คเกจนี้ได้

  • Version- เวอร์ชันของแพ็คเกจ ระบุไว้ในรูปแบบปปปปป

  • Release - ฟิลด์นี้หมายถึงรุ่นของเวอร์ชันเป็นหลัก

  • Summary - คำอธิบายสั้น ๆ ของแพ็คเกจ

  • Description - คำอธิบายรายละเอียดเพิ่มเติมของแพ็คเกจ

เครื่องปฏิกรณ์

ไฟล์เครื่องปฏิกรณ์อยู่ในไฟล์ /srv/spm/reactor/ ไดเรกทอรี

คอนเฟิม

ไฟล์ในแพ็กเกจประเภทนี้เป็นไฟล์คอนฟิกูเรชันสำหรับ Salt ซึ่งโดยปกติจะอยู่ในไฟล์ /etc/salt/ไดเรกทอรี ไฟล์คอนฟิกูเรชันสำหรับแพ็กเกจอื่นที่ไม่ใช่ Salt can และควรจัดการด้วย Salt State (โดยใช้แพ็กเกจประเภทสูตร)

ให้เราทำตามขั้นตอนต่อไปนี้เพื่อสร้างแพ็คเกจ

  • สร้างไฟล์ FORMULA และวางไว้ในรูทของโฟลเดอร์แพ็คเกจ

  • รวบรวมไฟล์สูตรในโฟลเดอร์บนระบบบิลด์

  • วิ่ง spm build. แพ็กเกจถูกสร้างและวางไว้ในโฟลเดอร์ / srv / spm_build คำสั่งต่อไปนี้ใช้เพื่อสร้างแพ็คเกจ

spm build /path/to/salt-packages-source/formula

  • ตอนนี้คัดลอกไฟล์ .spm ไฟล์ไปยังโฟลเดอร์บนระบบที่เก็บ

  • คุณสามารถแบ่งปันไฟล์ srv/spm_build โฟลเดอร์บนเครือข่ายหรือคัดลอกไฟล์ไปยัง FTP ของคุณหรือเว็บเซิร์ฟเวอร์

  • สร้างข้อมูลเมตาของ repo โดยใช้คำสั่งต่อไปนี้

spm create_repo /srv/spm_build

การติดตั้งแพ็คเกจ

ส่วนนี้จะอธิบายเกี่ยวกับการติดตั้งแพ็คเกจ Salt package manager

กำหนดค่าที่เก็บระยะไกล

ในการกำหนดค่าที่เก็บระยะไกล Salt Master จำเป็นต้องทราบว่าที่เก็บอยู่ที่ไหนผ่านกระบวนการกำหนดค่า

ไฟล์อยู่ในรูปแบบ /etc/salt/spm.repos.d/spm.repo ไดเรกทอรี

Example

file_repository:
   url: https://spm.example.com/

ที่นี่ไฟล์มีชื่อของที่เก็บและลิงก์ไปยังที่เก็บ คุณยังสามารถใช้ http, https, ftp หรือเส้นทางของไฟล์ ในการใช้เส้นทางไฟล์คุณสามารถเข้าถึงได้โดยใช้ URL: file: /// srv / spm_build

อัปเดตข้อมูลเมตา

หลังจากกำหนดค่าที่เก็บบน Salt master แล้วข้อมูลเมตาของที่เก็บจะถูกดาวน์โหลดโดยใช้คำสั่งด้านล่าง

spm update_repo

อัปเดต File Roots

แพ็คเกจ SPM อยู่ในไดเร็กทอรี srv / spm / salt เพิ่มพา ธ ต่อไปนี้ไปยังรูทไฟล์บน Salt master

file_roots:
   base:
      1. /srv/salt
      2. /srv/spm/salt

ตอนนี้เริ่มต้นเกลือใหม่

ติดตั้ง Apache Package

ในการติดตั้งแพ็กเกจ apache ให้ใช้คำสั่งต่อไปนี้

spm install apache

คุณยังสามารถติดตั้งได้โดยตรงจากไฟล์ SPM โดยใช้คำสั่งด้านล่าง

spm local install /srv/spm/apache-201607-1.spm

การลบแพ็คเกจ

หากต้องการลบแพ็คเกจตัวอย่างเช่น - apache ให้ใช้คำสั่งต่อไปนี้

spm remove apache

โปรดทราบว่าหากมีการแก้ไขไฟล์ใด ๆ ไฟล์เหล่านั้นจะไม่ถูกลบออก

Salt ให้การเข้าถึงแบบเป็นโปรแกรมสำหรับคำสั่งทั้งหมด Salt มีโมดูลที่แตกต่างกันสำหรับทุกส่วนของระบบ Salt ให้เราเรียนรู้พื้นฐานของ python API และวิธีเรียกใช้คำสั่ง salt พื้นฐานในบทนี้

การกำหนดค่า

salt.config โมดูลใช้เพื่อเข้าถึงรายละเอียดการกำหนดค่า Salt

import salt.config
opts = salt.config.client_config('/etc/salt/master')

ที่นี่ client_config อ่านไฟล์คอนฟิกูเรชัน salt และส่งกลับรายละเอียดการกำหนดค่าเป็นพจนานุกรม

รถตัก

salt.loader โมดูลใช้เพื่อโหลดแต่ละโมดูลใน Salt เช่นธัญพืชมินเนี่ยนเป็นต้น

import salt.loader
opts = salt.config.minion_config('/etc/salt/minion')
grains = salt.loader.grains(opts)

ที่นี่ grains อ่านรายละเอียดของธัญพืชในระบบเกลือและส่งคืน

โมดูลไคลเอนต์

salt.client โมดูลใช้เพื่อดำเนินการคำสั่ง salt, salt-call และ salt-SSH โดยทางโปรแกรม

คลาส python ที่สำคัญที่สุดมีดังนี้ -

  • salt.client.LocalClient
  • salt.client.Caller
  • salt.client.ssh.client.SSHClient

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

LocalClient

LocalClient ใช้เพื่อส่งคำสั่งจากมาสเตอร์ไปยังมินเนี่ยนเกลือและส่งผลลัพธ์กลับไปยังมาสเตอร์

import salt.client

local = salt.client.LocalClient()
local.cmd('*', 'test.ping')

มันจะผลิตสิ่งต่อไปนี้ output -

{'minion1': True, 'minion2': True }

ผู้โทร

Caller ใช้ในการเรียกใช้ salt-call โดยทางโปรแกรมและส่งคืนผลลัพธ์

import salt.client
caller = salt.client.Caller()
caller.cmd('test.ping')

มันจะผลิตสิ่งต่อไปนี้ output -

True

SSHClient

SSHCient ใช้เพื่อเรียกใช้ไฟล์ salt-ssh โดยทางโปรแกรมและส่งคืนผลลัพธ์

import salt.client.ssh.client
ssh = salt.client.ssh.client.SSHClient()
ssh.cmd('*', 'test.ping')

มันจะผลิตสิ่งต่อไปนี้ output -

{'minion1': True, 'minion2': True }

CloudClient

โมดูล salt.cloud ใช้เพื่อดำเนินการคำสั่ง salt-cloud โดยทางโปรแกรม

client = salt.cloud.CloudClient(path = '/etc/salt/cloud')

โมดูลคลาวด์มีฟังก์ชันในการสร้าง VMs (สร้าง) เพื่อทำลาย VM (ทำลาย) แสดงรายการรูปภาพที่ผู้ให้บริการระบบคลาวด์ (list_images) จัดเตรียมรายการตำแหน่งของผู้ให้บริการระบบคลาวด์ (list_locations) แสดงรายการขนาดเครื่องของผู้ให้บริการคลาวด์ (list_sizes) เป็นต้น

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

สูตรเกลือเป็นไฟล์ข้อความ YAML ที่เรียบง่ายและโดยค่าเริ่มต้นจะอยู่ใน Salt Master ของคุณในรูปแบบ /srv/salt/*. เริ่มต้นด้วยการสร้าง Salt Formula เพื่อติดตั้งเว็บเซิร์ฟเวอร์ Apache และ PHP ในเวลาเดียวกัน

สร้างไฟล์ชื่อ“ websetup.sls” ภายใต้ /srv/salt/ ไดเรกทอรีและเพิ่มรหัสต่อไปนี้

websetup.sls

websetup:
   pkg:
      - installed
      - pkgs:
         - apache2
         - php5
         - php5-mysql

ในตัวอย่างนี้ให้สังเกตอาร์กิวเมนต์“ - pkgs:” แต่ละรายการในรายการด้านล่าง“ - pkgs:” จะถูกส่งต่อไปยังตัวจัดการแพ็คเกจของ OS เพื่อติดตั้งร่วมกัน เมื่อใดก็ตามที่คุณมีรายการแพ็คเกจจำนวนมากเพื่อติดตั้งนี่เป็นวิธีที่มีประสิทธิภาพที่สุดในการติดตั้ง

นำสูตรนี้ไปใช้กับ Salt master โดยใช้คำสั่งต่อไปนี้

root@saltmaster:/home/vagrant# salt 'minion2' state.sls websetup

ตอนนี้คุณจะเห็นสิ่งต่อไปนี้ output -

minion2:
----------
   ID: websetup
   Function: pkg.installed
   Result: True
   Comment: 3 targeted packages were installed/updated.
   Started: 01:50:53.978396
   Duration: 86738.132 ms
   Changes:
      ----------
         apache2:
            ----------
            new:
               2.4.7-1ubuntu4.13
            old:
         apache2-api-20120211:
            ----------
            new:
               1
            old:
         apache2-bin:
            ----------
            new:
               2.4.7-1ubuntu4.13
            old:
         apache2-data:
            ----------
            new:
               2.4.7-1ubuntu4.13
            old:
         libapache2-mod-php5:
            ----------
            new:
               5.5.9+dfsg-1ubuntu4.21
            old:
         libapr1:
            ----------
            new:
               1.5.0-1
            old:
         libaprutil1:
            ----------
            new:
               1.5.3-1
            old:
         libaprutil1-dbd-sqlite3:
            ----------
            new:
               1.5.3-1
            old:
         libaprutil1-ldap:
            ----------
            new:
               1.5.3-1
            old:
         php5:
            ----------
            new:
               5.5.9+dfsg-1ubuntu4.21
            old:
         php5-cli:
            ----------
            new:
               5.5.9+dfsg-1ubuntu4.21
            old:
         php5-common:
            ----------
            new:
               5.5.9+dfsg-1ubuntu4.21
            old:
         php5-json:
            ----------
            new:
               1.3.2-2build1
            old:
         php5-mhash:
            ----------
            new:
               1
            old:
         php5-mysql:
            ----------
            new:
               5.5.9+dfsg-1ubuntu4.21
            old:
         php5-readline:
            ----------
            new:
               5.5.9+dfsg-1ubuntu4.21
            old:
         phpapi-20121212:
            ----------
            new:
               1
            old:
         ssl-cert:
            ----------
            new:
               1.0.33
            old:
Summary for minion2
------------
Succeeded: 1 (changed = 1)
Failed:    0
------------ 
Total states run:     1
Total run time:  86.738 s

ตอนนี้คุณได้ติดตั้งแพ็คเกจใน minion2.

รัฐสูง

“ ไฮสเตท” เป็นวิธีที่เกลือในการพิจารณาว่าสูตรเกลือใดที่ควรใช้กับมินเนี่ยนบางตัว ดำเนินการ“ highstate” โดยใช้คำสั่งต่อไปนี้

root@saltmaster:/home/vagrant# salt <targets> state.highstate

top.sls

เมื่อมินเนี่ยนร้องขอให้เรียกใช้ไฮสเตตตามที่กล่าวไว้ก่อนมินเนี่ยนจะร้องขอ top.sls จาก Salt master และค้นหาสูตรที่ตรง ตามค่าเริ่มต้นไฟล์นี้จะอยู่ที่ /srv/salt/top.sls ให้เราเพิ่มสูตรของเราไปที่ไฟล์ top.sls และตั้งค่า minion2 เป็นเป้าหมาย

base:
   '*':
      - common
   'minion2’:
      - websetup

ตอนนี้ดำเนินการ highstate กำหนดเป้าหมาย minion2 ดังที่แสดงด้านล่าง

root@saltmaster:/home/vagrant# salt 'minion2' state.highstate

หลังจากใช้สิ่งนี้คุณจะเห็นสิ่งต่อไปนี้ output -

minion2:
----------
   ID: common_packages
   Function: pkg.installed
   Result: True
   Comment: All specified packages are already installed
   Started: 01:55:17.998824
   Duration: 461.615 ms
   Changes:

Summary for minion2
------------
Succeeded: 1
Failed:    0
------------
Total states run:     1
Total run time: 461.615 ms

ตอนนี้เว็บเซิร์ฟเวอร์ Apache และ PHP ได้รับการติดตั้งใน minion2 แล้ว ด้วยวิธีนี้เราต้องกำหนดเป้าหมายให้มินเนี่ยนใช้ทั้งสองอย่างtop.sls และ highstate และติดตั้งซอฟต์แวร์ที่ต้องการโดยใช้งานน้อยที่สุดและมีความยืดหยุ่นสูงสุด

ja/tutorial
es/tutorial
de/tutorial
fr/tutorial
th/tutorial
pt/tutorial
ru/tutorial
vi/tutorial
it/tutorial
ko/tutorial
tr/tutorial
id/tutorial
pl/tutorial
hi/tutorial
japost
espost
depost
frpost
thpost
ptpost
rupost
vipost
itpost
kopost
trpost
idpost
plpost
hipost

© Copyright 2021 - 2024 | All Rights Reserved