‫เช่นเดียวกับ Docker Swarm มันใช้เรพลิกาเป็นคำศัพท์สำหรับคอนเทนเนอร์ต่างๆ
‫ที่ทำงานอยู่ และตัดสินใจว่าจะขยายและย่อขนาดอย่างไรโดยใช้จำนวนเรพลิกา และคำสั่งมาตราส่วน
‫เรามีประสบการณ์คล้ายกันกับ
‫Kubernetes ลองดูบรรทัดคำสั่ง kubectl
‫และวิธีใช้งาน
‫ขั้นแรก เราจะต้องเริ่มต้นการทำให้ใช้งานได้ใหม่
‫ลองกลับไปทำ kubectl รัน my-apache
‫-- ภาพ httpd.
‫คราวนี้ต่างจาก Nginx ตรงที่เรากำลังใช้งานเว็บเซิร์ฟเวอร์ Apache
‫ส่วนใหญ่เพียงเพราะมันทำให้เรามีการเริ่มต้นการล็อกเอาต์ออกจากกล่องเป็นค่าเริ่มต้น
‫อย่างน้อยที่สุดเราก็สามารถดูบันทึกได้
‫เราสามารถตรวจสอบว่าวัตถุเหล่านั้นทั้งหมดถูกปรับใช้กับวัตถุอื่นที่ได้รับทั้งหมด
‫เมื่อสิ่งที่คุณต้องการและปัจจุบันของคุณพร้อมที่จะไปยัง
‫ReplicaSet ของคุณ เช่นเดียวกับพ็อด เราก็จะรู้ว่าเราพร้อมที่จะทำคำสั่งต่อไป
‫การเรียกใช้เริ่มต้นนี้ทำให้เรามีพ็อดหรือแบบจำลองเดียว
‫ลองขยายเป็น 2
‫ขอให้สังเกตว่าฉันพิมพ์ --replicas 2 ที่นี่ด้วยคำสั่งมาตราส่วน
‫ฉันยังใส่ในประเภทของวัตถุ
‫กล่าวอีกนัยหนึ่งคือ การปรับใช้ แล้วตามด้วยชื่อของการทำให้ใช้งานได้นั้น
‫แต่มีรูปแบบอื่นที่คุณสังเกตเห็นว่าฉันเคยใช้ที่นี่
‫ฉันใช้การปรับใช้มากกว่าการปรับใช้
‫และฉันได้ใช้เครื่องหมายทับแทนที่จะเป็นช่องว่าง
‫นี่เป็นการอภิปรายเล็กน้อยเกี่ยวกับความยืดหยุ่นของบรรทัดคำสั่ง
‫Kubernetes
‫คุณจะสังเกตเห็นว่าคำสั่งจำนวนมากมีเวอร์ชันสั้นของคำสั่งนั้นเอง
‫ส่วนต่างๆ ของคำสั่งสามารถย่อหรือแทนที่ได้หลายวิธี
‫เช่น เครื่องหมายทับกับช่องว่าง
‫ของแบบนั้น. ในกรณีนี้ การปรับใช้มาตราส่วน
‫/ my-apache จะเหมือนกับพื้นที่การปรับใช้มาตราส่วนพื้นที่
‫my-apache
‫เหล่านั้นจะเทียบเท่ากัน
‫โดยพื้นฐานแล้วคุณสามารถเห็นตัวเลือกการปรับใช้ในหลาย
‫ๆ ที่ โดยพื้นฐานแล้ว คุณอาจระบุการปรับใช้ การปรับใช้
‫หรือการทำให้ใช้งานได้ในสถานะพหูพจน์
‫คุณจะสังเกตได้ว่าบางครั้งสิ่งนี้ก็คล้ายกันในส่วนอื่นๆ
‫ของบรรทัดคำสั่งที่พหูพจน์หรือเอกพจน์ก็ใช้ได้เช่นกัน
‫หรือบางครั้ง คุณสามารถย่อบางส่วนของคำสั่งได้
‫สุจริตในช่วงหลายปีที่ผ่านมานี้มีการเปลี่ยนแปลง
‫ดังนั้นจึงไม่ชัดเจนนักว่าส่วนใดที่คุณสามารถย่อหรือใส่เครื่องหมายทับเพื่อเว้นวรรคได้
‫แต่ฉันคิดว่าเมื่อคุณชินกับวิธีการทำสิ่งต่างๆ ของตัวเองแล้ว
‫นั่นก็ใช้ได้ผลสำหรับคุณ
‫ตอนนี้ ถ้าเราทำ kubectl อย่างรวดเร็ว รับทั้งหมดอีกครั้ง
‫คุณจะสังเกตเห็นว่าตอนนี้เรามีสองพ็อด
‫คุณจะเห็นว่า ReplicaSet ที่ด้านล่างมีสถานะที่ต้องการเป็นสองและสองกำลังทำงานอยู่
‫ตามแนวคิดทั่วไป นี่คือสิ่งที่บริการของ
‫Swarm ทำ พวกเขาปรับขนาดขึ้นและลงแบบจำลองตามความต้องการของคุณ
‫ในกรณีนี้ เราแค่พูดถึงพ็อดมากกว่างาน
‫เมื่อเราทำคำสั่งมาตราส่วน ให้ฉันอธิบายพื้นฐานเกี่ยวกับสิ่งที่เกิดขึ้นในพื้นหลัง
‫เนื่องจากเรามีความเป็นนามธรรมในระดับพิเศษ เราจึงต้องเข้าใจว่าระดับเหล่านี้มีปฏิกิริยาต่อกันและกันอย่างไร
‫เมื่อเราพิมพ์คำสั่ง scale เรากำลังอัปเดตข้อกำหนดการปรับใช้ในทางเทคนิค
‫ใน Kubernetes ทุกอย่างมีข้อกำหนด
‫ข้อมูลจำเพาะสำหรับการปรับใช้นี้เปลี่ยน
‫ReplicaSet เป็นชุดของแบบจำลองสองชุด
‫จากนั้นตัวควบคุม ReplicaSet นั้นก็ตัดสินใจเปลี่ยนเป็นสองพ็อด
‫และจะมีหนึ่งพ็อดสำหรับแต่ละแบบจำลอง
‫จากนั้นเครื่องบินควบคุมจะตัดสินใจว่าโหนดใด ในกรณีนี้
‫คุณมีโหนดเพียงโหนดเดียว แต่โหนดใดจะได้รับมอบหมายให้พ็อดเหล่านั้น
‫จากนั้น หากคุณมีการตั้งค่าแบบหลายโหนด
‫ตัวแทน kubelet จะได้รับมอบหมายพ็อดนั้นและจะดำเนินการสร้างคอนเทนเนอร์บน
‫Docker Engine ในเครื่องของเขา
‫แม้ว่าจะดูเหมือนเป็นงานจำนวนมากที่เกิดขึ้นบนพื้นหลังเพียงเพื่อเริ่มคอนเทนเนอร์อื่น
‫แต่จริงๆ แล้วเกิดขึ้นเร็วมาก
‫อันที่จริง
‫มันเกิดขึ้นเกือบจะเร็วพอๆ กับ Swarm โดยทั่วไป เรากำลังพูดถึงวินาที
‫สองวินาที บางอย่างเช่นนั้น เมื่อพูดถึงเครื่องเดียว
‫ด้วย Swarm ข้อดีอย่างหนึ่งของ Swarm คือทุกอย่างอยู่ในเลขฐานสองเดียว
‫ดังนั้น มันจึงเกิดขึ้นเร็วกว่ามาก เพราะมันเกิดขึ้นจริงภายในกระบวนการเดียวกัน
‫ซึ่งรวมถึงการเปิดตัวคอนเทนเนอร์ด้วย
‫ด้วย Kubernetes เราได้รับชั้นนามธรรมเพิ่มเติมเหล่านี้
‫นั่นทำให้เกิดความล่าช้าเล็กน้อยเมื่อเทียบกับสิ่งที่คุณจะทำ
‫Docker หรือ Swarm
‫แต่จริงๆ แล้ว ในกรณีส่วนใหญ่ มันเป็นเรื่องเล็กน้อย
‫ข้อเสียคือเรามีความยืดหยุ่นและควบคุมได้มากขึ้นด้วยชั้นนามธรรมต่างๆ
‫เหล่านี้
‫โอ้! อย่าล้างเรื่องนี้
‫เราจะใช้คอนเทนเนอร์ Apache เหล่านี้ในการบรรยายครั้งต่อไปเมื่อเราตรวจสอบสิ่งที่เกิดขึ้นใน
‫Kubernetes