‫โอ้มนุษย์ ฉันพนันได้เลยว่าคุณกำลังรอที่จะไปที่บรรทัดคำสั่ง
‫Kubernetes มาระยะหนึ่งแล้ว
‫แต่โชคดีที่เรามีแนวคิดบางอย่างออกไปให้พ้นทาง
‫ดังนั้น มาที่บรรทัดคำสั่งกัน
‫สิ่งแรกที่เราต้องทำให้แน่ใจว่าสิ่งที่คุณทำกับการตั้งค่า
‫Kubernetes นั้นทำงานอยู่
‫วิธีที่เราสามารถทำได้นั้นคล้ายกับเวอร์ชัน Docker และเวอร์ชัน
‫Compose และอะไรทำนองนั้น
‫เราสามารถไปที่เชลล์แล้วพิมพ์
‫kubectl นั่นคือเวอร์ชัน K U B E
‫C T L คุณควรกลับไปใช้เวอร์ชันต่างๆ
‫นี่เป็นเหมือนกับ Docker ที่คุณได้รับเวอร์ชันไคลเอ็นต์และเวอร์ชันเซิร์ฟเวอร์
‫โปรดจำไว้ว่าเครื่องมือบรรทัดคำสั่งทั้งหมดเหล่านี้กำลังพูดคุยกับ
‫API ระยะไกล
‫ในกรณีนี้ อาจเป็น API บนเครื่องของคุณ
‫เช่นเดียวกับ Docker และ Swarm และ Compose บรรทัดคำสั่ง
‫kubectl ยังสามารถพูดคุยกับ Kubernetes API ระยะไกลได้อีกด้วย
‫ตอนนี้คุณได้คืนเวอร์ชันเซิร์ฟเวอร์ไคลเอ็นต์แล้ว
‫คุณก็พร้อมแล้วที่จะไป หากคุณได้รับข้อผิดพลาด อาจเป็นเพราะเวอร์ชันเซิร์ฟเวอร์ไม่ปรากฏขึ้นและแจ้งว่าไม่สามารถเชื่อมต่อได้
‫นั่นหมายความว่าคุณกำหนดค่าผิดพลาดและ
‫CLI ในเครื่องของคุณไม่สามารถพูดคุยกับเซิร์ฟเวอร์ Kubernetes ได้
‫ฉันจะตรวจสอบวิธีที่คุณปรับใช้เพื่อให้แน่ใจว่าทำงานอยู่
‫บางทีถ้าคุณใช้ Docker Desktop คุณต้องเริ่ม Docker
‫จากนั้นตรวจสอบให้แน่ใจในการตั้งค่าที่ Kubernetes
‫ทำงานอยู่ หากเป็นอย่างอื่น ให้ตรวจสอบวิดีโอการติดตั้ง
‫หากคุณมีปัญหาใดๆ
‫โปรดติดต่อในส่วนถาม & ตอบหรือใน Slack
‫ไม่เป็นไร. มีสองวิธีในการปรับใช้พ็อดใน
‫Kubernetes จริงๆ ทำได้ที่บรรทัดคำสั่งที่คุณระบุตัวเลือกทั้งหมดที่บรรทัดคำสั่ง
‫หรือมีการใช้ YAML
‫แนวคิดนี้อาจคล้ายคลึงกันกับบริการและสแต็คใน Swarm แต่แน่นอนว่า
‫เมื่อคุณลงมือจริงๆ แล้ว มีอะไรอีกมากมายอยู่ใต้หน้าปก
‫ดังนั้นฉันจึงเกลียดที่จะทำการเปรียบเทียบนั้น
‫แต่นั่นเป็นสองตัวเลือกจริง ๆ ที่คุณมีคือบรรทัดคำสั่งหรือ YAML
‫มาโฟกัสที่บรรทัดคำสั่งกันสักครู่
‫คำสั่งแรกที่เราจะเรียกใช้ที่นี่คือ
‫kubectl run
‫ดังนั้นจึงคล้ายกับการรันนักเทียบท่า
‫My Nginx และคุณสามารถเรียกมันว่าอะไรก็ได้ที่คุณต้องการ
‫นี่คือชื่อการทำให้ใช้งานได้ของคุณ จากนั้น --image และเราจะระบุชื่อภาพที่นี่
‫ลองใช้ Nginx เหมือนที่เราคุ้นเคยและกด return
‫โปรดละเว้นคำเตือนที่คิดค่าเสื่อมราคาไว้สักครู่ หากคุณได้รับการแจ้งเตือนดังกล่าวใน
‫Kubernetes เวอร์ชันล่าสุดบางเวอร์ชัน
‫เราจะพูดถึงเรื่องนี้กันสักหน่อย
‫แต่สำหรับตอนนี้เรามาดูกันว่าเกิดอะไรขึ้น
‫เราสามารถใช้สิ่งนั้นกับคำสั่ง kubectl get
‫kubectl รับฝัก
‫สิ่งที่คุณควรเห็นคือคุณถูกตั้งชื่อว่าอ็อบเจกต์
‫พร้อมด้วยอักขระบางตัวที่ส่วนท้าย และคุณจะเห็นว่า
‫1 ใน 1 กำลังทำงานอยู่
‫ซึ่งคล้ายกับแนวคิดบริการใน Swarm มาก โดยค่าเริ่มต้นเราจะเรียกใช้แบบจำลองเพียงตัวเดียว
‫คุณจะเห็นชื่อที่นั่น
‫ทำไมเราถึงมีชื่อแปลก ๆ นั้น?
‫สิ่งนี้เกี่ยวข้องกับวิธีการทำงานของคำสั่ง
‫kubectl run
‫เมื่อคุณใช้การวิ่งตามที่เป็นอยู่ในเวอร์ชัน
‫1 ในขณะนี้ 14 นั่นคือในทางเทคนิคโดยใช้ตัวควบคุมการปรับใช้
‫ตัวควบคุมการปรับใช้นั้นสร้างตัวควบคุม ReplicaSet
‫ตัวควบคุม ReplicateSet นั้นจะสร้างพ็อด
‫ในกรณีนี้ เป็นเพียงแบบจำลองเดียว
‫เลยมีแค่แปปเดียว
‫หากเราทำ kubectl ได้ทั้งหมด คุณจะเห็นวัตถุทั้งหมดที่อยู่ในรายการ
‫คุณจะเห็นฝัก
‫ละเว้นบริการสำหรับตอนนี้
‫เราจะพูดถึงเรื่องนี้กันสักหน่อย
‫การปรับใช้และใน ReplicaSet
‫คุณสามารถเห็นเลเยอร์ต่างๆ ของโมเดลอ็อบเจ็กต์และ
‫Kubernetes ออกมาที่นี่ โดยที่เราเพิ่งใช้คำสั่งเดียว แต่จริงๆ
‫แล้ว มันสร้างหลายอ็อบเจ็กต์สำหรับเรา
‫ไปที่กระดานวาดภาพของฉันและอธิบายว่าวัตถุเหล่านี้เกี่ยวข้องกันอย่างไร
‫ดังที่คุณเคยเห็นใน Kubernetes เรามีระดับความเป็นนามธรรมและการควบคุมมากกว่าที่เคยทำใน
‫Swarm หรือใน Docker
‫ในกรณีนี้ เมื่อเรารัน kubectl มันสร้าง
‫abstractions ต่างๆ มากมายให้เราโดยอัตโนมัติในเบื้องหลัง
‫มันสร้างพ็อด แต่ยังสร้างรอบชุดจำลองนั้นและรอบนั้นคือการปรับใช้
‫ไปที่กระดานวาดภาพกัน และฉันจะแสดงให้คุณเห็นว่านามธรรมเหล่านี้เกี่ยวข้องกันอย่างไร
‫เพื่อเป็นการเตือนความจำ เรามี Docker ทำงานอยู่ข้างใต้
‫จากนั้นเราก็มีคอนเทนเนอร์ที่ทำงานอยู่ซึ่งกำลังจัดการ Kubernetes และฉันจะไม่พูดถึงตอนนี้
‫ให้รู้ว่าเรามีชุดคอนเทนเนอร์ที่แตกต่างกันตรงนี้เพื่อเรียกใช้
‫Kube
‫เมื่อเราทำ kubectl run สิ่งที่มันสร้างขึ้นคือคอนเทนเนอร์
‫Nginx ของเราอย่างชัดเจน นั่นคือส่วนที่เรารู้
‫แต่ระดับการควบคุมที่แตกต่างกันหรือสิ่งที่เป็นนามธรรมเป็นส่วนที่น่าสนใจ
‫คนแรกที่นี่คือพ็อด
‫อีกครั้ง มันสามารถเรียกใช้คอนเทนเนอร์อย่างน้อยหนึ่งรายการภายในพ็อดนี้
‫ส่วนหนึ่งของพ็อดนั้นสามารถสร้างวอลุ่มได้ถ้าเราต้องการ
‫มันสร้าง
‫NIC สำหรับพ็อด
‫วิธีสร้างพ็อดนั้นคือเมื่อเราพิมพ์
‫kubectl run มันสร้างการปรับใช้
‫ตัวควบคุมการปรับใช้จัดการ ReplicaSets
‫เรามีนามธรรมหลายระดับ
‫การปรับใช้นั้นถูกสร้างขึ้น และทำสิ่งต่างๆ เช่น
‫การอัปเดตแบบต่อเนื่อง หรือการปรับใช้สีน้ำเงิน/สีเขียว
‫และอีกมากมายที่คุณนึกถึงเมื่อคุณนึกถึงบริการการประสานเช่นเดียวกับที่เรามีในบริการ
‫Swarm
‫เมื่อ Deployment ถูกสร้างขึ้น มันจะสร้าง ReplicaSet
‫ขึ้นมาหนึ่งชุด
‫ตัวมันเองเป็นตัวควบคุมอื่น
‫งานของ ReplicaSet คือการตรวจสอบให้แน่ใจว่าจำนวนพ็อดที่เราขอกำลังทำงานอยู่
‫ในกรณีนี้ เราปล่อยให้ทุกอย่างเป็นค่าเริ่มต้น
‫ดังนั้น การปรับใช้ของเราจึงสร้าง ReplicaSet หนึ่งชุด
‫และ ReplicaSet นั้นสร้างหนึ่งพ็อด
‫เราสามารถควบคุมระดับนามธรรมที่แตกต่างกันเหล่านี้ได้
‫เราสามารถพิมพ์คำสั่งเพื่อควบคุมการปรับใช้
‫ReplicaSet หรือพ็อดเองโดยตรง
‫แต่โดยปกติในสถานการณ์เหล่านี้ คุณจะต้องจัดการการปรับใช้เองเสมอ
‫แล้วที่เหลือจะดูแลเอง
‫เพื่อให้คุณได้ทราบว่าเหตุใด ReplicaSet จึงอยู่ตรงกลาง
‫นั่นคือถ้าเราต้องการสร้างสำเนาของพ็อดนี้อีกชุดหนึ่ง
‫เช่นเดียวกับเมื่อเราสร้างแบบจำลองบริการ
‫Swarm
‫ในภาพวาดของฉันที่นี่ ฉันได้สร้างสำเนาของพ็อดนั้น
‫นั่นจะเป็นถ้าเราปรับขนาดแบบจำลองเป็นสองส่วน
‫คล้ายกันมากกับวิธีที่ Swarm ทำ
‫งานของ ReplicaSet อีกครั้งคือทำให้แน่ใจว่าสองพ็อดกำลังทำงานด้วยเทมเพลตที่เหมือนกัน
‫งานของการปรับใช้คือการจัดการการกำหนดค่า
‫ReplicaSet
‫ก่อนที่เราจะข้ามไปยังการบรรยายครั้งต่อไป ให้ลบทรัพยากรทั้งหมดที่เราเพิ่งสร้างด้วยคำสั่ง
‫run โดยใช้คำสั่ง delete
‫สิ่งนี้แตกต่างจาก Docker ที่ Docker
‫มีคำสั่งลบ
‫ตอนนี้ เรากำลังใช้คำสั่ง delete กับ kubectl
‫คุณจะสังเกตเห็นว่าเรากำลังระบุประเภทของวัตถุแล้วตามด้วยชื่อของตัวเอง
‫เรากำลังสร้างพื้นที่การปรับใช้
‫ชื่อของการทำให้ใช้งานได้
‫เมื่อคุณทำเช่นนั้น มันจะลบทุกสิ่งที่อยู่ด้านล่าง
‫ReplicaSet
‫ตัวพ็อดเองและคอนเทนเนอร์ในนั้น
‫เราสามารถตรวจสอบได้อย่างรวดเร็วด้วยคำสั่ง get all เดียวกัน
‫คุณจะเห็นเฉพาะ IP ของคลัสเตอร์ที่นั่น ซึ่งก็คือเซิร์ฟเวอร์
‫Kubernetes เอง