‫Kubernetes มีหลายสิ่งหลายอย่าง
‫ฉันต้องการแยกแยะโทโพโลยีพื้นฐานและบางส่วนของระบบก่อนที่เราจะทำการติดตั้งแอปบน
‫Kubernetes อันดับแรกคือ Kubernetes เอง
‫นั่นคือสิ่งที่ฉันกำลังพูดถึง
‫ทั้งระบบ.
‫ไม่ว่าจะตั้งค่าเซิร์ฟเวอร์เดียวหรือหลายเซิร์ฟเวอร์พร้อมส่วนต่างๆ
‫ร่วมกันเพื่อเรียกใช้แอปของคุณ
‫เราย่อว่าบางครั้งเป็น K8s
‫โดยปกติเมื่อฉันพูดถึง Kubernetes ฉันจะพูดว่า
‫Kubernetes แต่บ่อยครั้งในการเขียน หรือแม้แต่ในเอกสารประกอบ
‫คุณจะเห็น K8 และนั่นคือ Kubernetes
‫เวอร์ชันย่อสั้นๆ
‫หากคุณดูจริงๆ
‫8 หมายถึงตัวอักษร 8 ตัวระหว่าง K และ S
‫นั่นเป็นเหตุผลที่พวกเขาทำมัน ตัว K แปดตัว แล้วก็ S
‫นั่นคือคำย่อของพวกเขา
‫บางครั้งผู้คนอาจเรียกมันว่า Kube
‫แต่โดยพื้นฐานแล้วเราจะพูดถึงสิ่งเดียวกันเมื่อเราพูดถึง
‫Kubernetes และ K8
‫ตอนนี้ kubectl เป็นเครื่องมือบรรทัดคำสั่งที่คุณจะใช้ในการพูดคุยกับ
‫Kubernetes API
‫วิธีหลักที่เราพูดคุยกับ Kubernetes คือการใช้ API
‫มีเครื่องมือหลายอย่างที่สามารถทำได้
‫ที่จริงแล้ว มีเครื่องมือมากมายที่พวกเขาสามารถพูดคุยกับ API ได้
‫อันที่มาจากโปรเจ็กต์อย่างเป็นทางการจริงๆ และเราจะใช้เวลาส่วนใหญ่คือ
‫kubectl
‫ตอนนี้ คุณอาจเห็นสิ่งนี้ถูกอ้างถึงในวิดีโออื่น
‫ๆ หรือพูดคุย ในรูปแบบคิวบ์หรือคิวบ์
‫หรือคิวบ์คอนโทรล ประเภทอื่น ๆ ทั้งหมด หรือแม้แต่
‫kubectl ก็ตาม แต่สิ่งเหล่านี้ล้วนเป็นสิ่งเดียวกัน
‫พวกเขาเป็นคนที่แตกต่างกันโดยพื้นฐานแล้วพูดเป็นอย่างอื่น
‫อันที่จริงเมื่อประมาณหนึ่งปีที่แล้วพวกเขาตัดสินใจเรียกเครื่องมือนี้ว่า
‫kubectl อย่างเป็นทางการในเอกสารประกอบ
‫แต่ไม่มีทางพูดผิดจริงๆ
‫เช่นเดียวกับ Swarm ที่เราเรียกโหนดว่าเซิร์ฟเวอร์ที่อยู่ภายในคลัสเตอร์นั้น
‫Kubernetes ยังหมายถึงสิ่งต่าง ๆ เป็นโหนดเช่นกัน
‫ดังนั้น คำศัพท์นั้นอย่างน้อยก็เหมือนกันระหว่างทั้งสอง
‫Kubelet เป็นคอนเทนเนอร์ที่จะเรียกใช้เอเจนต์ขนาดเล็กและเล็กในแต่ละโหนดเพื่อให้โหนดนั้นสามารถพูดคุยกับต้นแบบ
‫Kubernetes ได้
‫โปรดจำไว้ว่า เนื่องจาก Docker มี Swarm ในตัว จึงไม่จำเป็นต้องมีตัวแทนแยกต่างหาก
‫ทั้งหมดนี้มีอยู่ใน Docker Engine
‫ขณะนี้ Kubernetes ทำงานอยู่ด้านบนนั้น มันต้องมีเอ็นจิ้น
‫API ของตัวเองที่พูดคุยกับ Docker ในเครื่อง หรือรันไทม์ในเครื่อง
‫แล้วแต่ว่าจะเป็นอย่างใด
‫จากนั้นจะตอบกลับไปยังระนาบควบคุมหรือมาสเตอร์
‫ซึ่งรับผิดชอบการรันคลัสเตอร์ Kubernetes
‫ระนาบควบคุม ซึ่งบางครั้งเรียกว่าต้นแบบ คือสิ่งที่รับผิดชอบคลัสเตอร์
‫หากคุณคุ้นเคยกับ Swarm
‫ใน Swarm เรามีผู้จัดการ
‫อาจมีผู้จัดการตั้งแต่หนึ่งคนขึ้นไป
‫เราต้องการผู้จัดการจำนวนคี่
‫จากนั้นก็มีคนงานที่ทำงานทั้งหมด
‫ถ้าคุณจำได้จาก Swarm ผู้จัดการก็อาจเป็นคนงานได้เช่นกันเพราะพวกเขาสามารถจัดการตู้คอนเทนเนอร์เองได้
‫ในทางเทคนิคแล้ว
‫คุณสามารถมีเซิร์ฟเวอร์เพียงเครื่องเดียวได้ คุณสามารถมีเซิร์ฟเวอร์จำนวนมากและแยกสองบทบาทออกได้
‫หลายอย่างที่คล้ายกันมากใน Kubernetes
‫เรามีชื่อเรียกต่างกันเล็กน้อย
‫ระนาบควบคุม ซึ่งเป็นสิ่งที่เราใช้ใน
‫Swarm เช่นกัน เป็นส่วนที่เซิร์ฟเวอร์ใช้งานทุกสิ่งที่รับผิดชอบเป็นหลัก
‫มีมากกว่าหนึ่งคอนเทนเนอร์ เป็นกลุ่มของตู้คอนเทนเนอร์
‫พวกเขาทำงานแต่ละอย่าง
‫พวกเขาใช้หลักการของลินุกซ์ในการทำสิ่งหนึ่งและทำได้ดี
‫และพวกเขารับมันและแยกทุกอย่างออกจากกัน
‫ดังนั้น
‫โดยพื้นฐานแล้ว แต่ละส่วนเหล่านี้กำลังทำสิ่งหนึ่งและทำได้ดี และทำให้การออกแบบง่ายขึ้นในแง่ของการพัฒนา
‫แต่เมื่อคุณต้องสร้างสิ่งนี้และใช้งาน มันทำให้การตั้งค่ายากขึ้นเล็กน้อย
‫เพราะมันยังมีอีกมาก ระนาบการควบคุมนี้รวมถึงคอนเทนเนอร์ที่จะเรียกใช้
‫API ตัวจัดกำหนดการ คุณต้องมีแบ็กเอนด์ฐานข้อมูลที่จะเป็นสิ่งที่เรียกว่า etcd
‫จากนั้นคุณมีผู้จัดการตัวควบคุม
‫คุณอาจต้องการสิ่งที่เรียกว่า coreDNS เพื่อจัดการ
‫DNS ของคุณ เป็นต้น
‫เรามีส่วนต่างๆ มากมายที่นี่ แต่ลองใส่ไว้ในไดอะแกรมและดูว่าสิ่งนี้เหมาะสมหรือไม่
‫ฉันจะเปรียบเทียบกับ Swarm เนื่องจากคุณได้เรียนรู้แล้วในหลักสูตรนี้
‫หากคุณมีเครื่องเพียงเครื่องเดียว อย่างที่เรากำลังจะทำในไม่กี่นาทีเพื่อเรียนรู้
‫ทุกสิ่งที่ฉันอ้างถึงก่อนหน้านี้จะอยู่ในเซิร์ฟเวอร์เดียวกัน
‫จะมีพวงของภาชนะวิ่ง นั่นคือสิ่งที่คุณจะเห็นในสิ่งต่างๆ
‫เช่น minikube และ Docker Desktop เมื่อคุณใช้งาน Kubernetes
‫โหนดเดียว
‫ในโลกแห่งความเป็นจริงเมื่อคุณเข้าสู่เซิร์ฟเวอร์ คุณจะต้องทำลายสิ่งนี้
‫ฉันคิดว่าฉันจะแสดงให้คุณเห็นอย่างรวดเร็วจริงๆ
‫ในแผนภาพเครือข่าย สิ่งนี้อาจมีลักษณะอย่างไรและอธิบายส่วนต่างๆ
‫ขั้นแรก สมมติว่าคุณมีปรมาจารย์
‫ในการตั้งค่าต้นแบบหลายรายการ คุณจะมีสามรายการดังกล่าว
‫เช่นเดียวกับ
‫Swarm คุณต้องมีเลขคี่เพราะใช้โปรโตคอล RAFT เดียวกันเพื่อให้ฉันทามติเหมือนที่
‫Swarm ทำ
‫ในเอกสารประกอบ สิ่งเหล่านี้เรียกว่ามาสเตอร์
‫แต่จะทำให้เกิดความสับสนเล็กน้อยเมื่อคุณมีต้นแบบมากกว่าหนึ่งตัว
‫เนื่องจากเป็นการตั้งค่าแบบเดียวกันซึ่งคุณสามารถมีได้เพียงอันเดียวที่ทำหน้าที่เขียน
‫etcd จริงๆ
‫สิ่งเหล่านี้เรียกว่าระนาบควบคุม
‫คุณจะรู้จักคำนั้นจาก Swarm ซึ่งหมายถึงโปรโตคอลใน
‫Swarm โดยเฉพาะบนเครือข่ายที่อนุญาตให้มาสเตอร์และโหนดทั้งหมดพูดคุยอย่างปลอดภัยเพื่อออกคำสั่ง
‫แต่ที่นี่แตกต่างกันเล็กน้อย
‫ระนาบควบคุมกำลังพูดถึงโหนดหลักที่กำลังตัดสินใจอยู่
‫เช่นเดียวกับ Swarm เรามีโหนดผู้ปฏิบัติงาน
‫ในเอกสารประกอบ พวกมันจะถูกเรียกว่าโหนดจริงๆ
‫บางครั้งคุณเห็นคำว่าคนงานกล่าวถึง
‫เราจะเรียกโหนดเหล่านั้นที่นี่เพื่อให้สอดคล้องกัน
‫เช่นเดียวกับเมื่อก่อน สิ่งเหล่านี้สามารถเรียกใช้คอนเทนเนอร์ได้
‫แต่โดยทั่วไป คุณจะต้องเก็บแอปของคุณไว้ที่โหนด
‫และระบบการจัดการ Kubernetes ให้กับมาสเตอร์
‫ทั้งหมดนี้ทำงานบน Docker
‫หรือรันไทม์คอนเทนเนอร์อื่นๆ เช่น containerd
‫หรือ crio
‫ภายในต้นแบบแต่ละอัน เราจะต้องเรียกใช้คอนเทนเนอร์หลายตัวเพื่อควบคุมระบบ
‫อย่างแรกคือ etcd
‫Etcd เป็นระบบจัดเก็บข้อมูลแบบกระจายสำหรับค่าคีย์
‫คล้ายกับวิธีที่ Swarm ทำงานกับระบบอัลกอริธึม
‫RAFT
‫คล้ายกับ etcd แต่ etcd เป็นผลิตภัณฑ์แยกต่างหากและเป็นสิ่งที่คุณสามารถติดตั้งได้โดยไม่ต้องใช้
‫Kubernetes เพียงเพื่อเก็บข้อมูลการกำหนดค่า
‫มันใช้โปรโตคอล RAFT เดียวกัน ดังนั้นจึงใช้กฎเดียวกันมากมาย
‫คุณต้องมีเลขคี่
‫คุณสามารถเริ่มต้นด้วยสิ่งหนึ่ง แต่ถ้าคุณต้องการความทนทานต่อข้อผิดพลาดที่แท้จริง
‫คุณต้องมีสามอย่าง
‫และอื่นๆ. ยิ่งไปกว่านั้น คุณจะต้องเรียกใช้คอนเทนเนอร์
‫Kubernetes หลายตัวที่จะจัดเก็บข้อมูลภายใน etcd และจัดการคลัสเตอร์
‫อย่างแรกคือ API ซึ่งจะเป็นวิธีที่เราพูดคุยกับคลัสเตอร์นี้และออกคำสั่งให้กับคลัสเตอร์นี้
‫ถัดไปคือคอนเทนเนอร์ตัวจัดกำหนดการ ซึ่งจะควบคุมวิธีการและตำแหน่งที่คอนเทนเนอร์ของคุณวางบนโหนดในอ็อบเจ็กต์ที่เรียกว่าพ็อด
‫ถัดมาคือตัวจัดการตัวควบคุม ซึ่งจะตรวจสอบสถานะของคลัสเตอร์ทั้งหมด
‫และทุกอย่างที่ทำงานอยู่ในนั้น และใช้ API
‫ในการทำเช่นนั้น
‫ใช้คำสั่งที่ให้มาหรือข้อกำหนด และกำหนดความแตกต่างระหว่างสิ่งที่คุณขอให้ทำกับสิ่งที่เกิดขึ้นจริง
‫โดยพื้นฐานแล้วมันคือการวนซ้ำที่มองเห็นทั้งระบบและหาวิธีทำให้ทุกอย่างที่เกิดขึ้นในปัจจุบันเหมือนกับที่คุณขอให้ทำ
‫จากนั้นคุณจะต้องมีบางสิ่งในการควบคุม
‫DNS ซึ่งไม่ได้สร้างขึ้นและโดยค่าเริ่มต้นนั่นคือ coreDNS
‫ขึ้นอยู่กับส่วนเสริมอื่นๆ ที่คุณได้รับในภายหลัง
‫เช่น เครือข่ายหรือที่เก็บข้อมูล เว็บและคุณสมบัติอื่นๆ
‫คุณจะมีคอนเทนเนอร์ที่ทำงานที่นี่มากขึ้นเช่นกัน
‫บนโหนดทั้งหมด พวกเขาต้องการเอเจนต์ที่ทำงานอยู่
‫ที่รู้จักกันในชื่อ kubelet
‫ในการเริ่มต้น คุณจะต้องใช้ kube-proxy เพื่อควบคุมเครือข่าย
‫เช่นเดียวกับ Docker สิ่งเหล่านี้จะถูกทำซ้ำสำหรับบทบาทของพวกเขา
‫มาสเตอร์
‫ถ้าคุณจะทำหลายมาสเตอร์ จะต้องมีคอนเทนเนอร์เดียวกันทั้งหมดตั้งขึ้น
‫แต่ละโหนดที่คุณตั้งค่าสำหรับโหนดของผู้ปฏิบัติงานจะมีคอนเทนเนอร์อย่างน้อยสองคอนเทนเนอร์สำหรับการจัดการ
‫Kubernetes
‫ออกแบบมาเพื่อแก้ปัญหามากมายในหลากหลายวิธี
‫คุณจะพบว่าตัวเองสามารถเพิ่มสิ่งต่าง ๆ ให้กับผู้เชี่ยวชาญ
‫สิ่งต่าง ๆ ให้กับโหนด เช่น เครือข่าย
‫ในด้านของมาสเตอร์ มีเครื่องมือเสริมอื่นๆ มากมายที่คุณสามารถเพิ่มเข้าไปได้เช่นกัน
‫มาติดตั้งสิ่งนี้บนระบบท้องถิ่นของคุณเพื่อการเรียนรู้