Kubernetes Networking: คู่มือฉบับสมบูรณ์เพื่อทำความเข้าใจโมเดลเครือข่าย

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

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

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

มาดำดิ่งกัน

Kubernetes คืออะไร?

ก่อนที่เราจะเริ่มต้นการสนทนาเกี่ยวกับเครือข่ายใน Kubernetes เราต้องพิจารณาแนวคิดพื้นฐานของเครื่องมือนี้ ด้วยวิธีนี้ คุณจะไม่ต้องเผชิญกับความสับสนในบทความต่อไปและมีความเข้าใจพื้นฐานในทุกสิ่งที่กล่าวถึงในที่นี้

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

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

เหตุใดจึงใช้ Kubernetes

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

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

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

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

ส่วนประกอบของ Kubernetes

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

ฝัก

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

คอนโทรลเลอร์

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

โหนด

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

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

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

เมื่อคุณคุ้นเคยกับองค์ประกอบของเครือข่าย Kubernetes แล้ว เราสามารถเริ่มต้นด้วยโมเดลเครือข่ายและวิธีการทำงาน

Kubernetes Networking อธิบาย

เครือข่าย Kubernetes เป็นไปตามรูปแบบเฉพาะที่มีข้อจำกัดดังต่อไปนี้:

• พ็อดสื่อสารกับพ็อดอื่นๆ ทั้งหมดโดยไม่มีการแปลที่อยู่เครือข่าย
• Nods สามารถสื่อสารกับ Pods ได้โดยไม่ต้องแปลที่อยู่เครือข่าย
• IP ของ Pod ที่ Pod อื่น ๆ เห็นว่าเป็น IP เดียวกันกับตัวมันเอง

เนื่องจากข้อจำกัดเหล่านี้ Kubernetes จึงมีเพียงส่วนเครือข่ายบางส่วนเท่านั้น พวกเขาเป็น:

• การขนส่งตู้คอนเทนเนอร์ไปยังตู้คอนเทนเนอร์
• การโอนจากพ็อดไปยังพ็อด
• Pod เพื่อบริการรับส่ง
• อินเทอร์เน็ตเพื่อบริการโอน

คอนเทนเนอร์ไปยังคอนเทนเนอร์

คุณอาจคิดว่าในระบบเครือข่าย เครื่องเสมือนโต้ตอบกับอุปกรณ์อีเทอร์เน็ตโดยตรง แต่มีมากกว่านั้น

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

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

Pod to Pod

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

พ็อดสื่อสารผ่านโหนดของพวกเขา นั่นคือเหตุผลที่ต้องเข้าใจการสื่อสารระหว่าง Pod to Pod และคุณจะต้องเข้าใจปฏิสัมพันธ์ระหว่างโหนด

• การสื่อสารระหว่างโหนด
• การสื่อสารภายในโหนด

เราจะพูดถึงรายละเอียดแต่ละรายการ:

การสื่อสารระหว่างโหนด

เมื่อโหนดตั้งอยู่ในพ็อดต่างๆ โหนดจะสื่อสารกันด้วยวิธีนี้ เราสามารถเข้าใจวิธีการสื่อสารนี้ผ่านตัวอย่างง่ายๆ สมมติว่ามีเครือข่ายพ็อดต่างๆ อยู่สี่เครือข่าย ได้แก่ พ็อด 1 พ็อด 2 พ็อด 3 เป็นต้น พ็อด 1 และ 2 อยู่ในเครือข่ายรูทโหนด 1 และพ็อด 3 และ 4 อยู่ในเครือข่ายที่ 2

คุณต้องโอนแพ็กเก็ตจากพ็อด 1 ไปยังพ็อด 4

แพ็กเก็ตต้องออกจากเครือข่าย pod 1 ก่อนและเข้าสู่เครือข่ายรูทผ่าน veth0 มันผ่านลินุกซ์บริดจ์ซึ่งช่วยในการค้นหาปลายทาง เนื่องจากโหนดไม่มีเป้าหมายภายใน Pod จึงส่งกลับไปยังอินเทอร์เฟซ eth0 ตอนนี้ออกจากโหนดแรกสำหรับตารางเส้นทาง ตารางเส้นทางจะกำหนดเส้นทางแพ็กเก็ตไปยังโหนดที่ต้องการ ซึ่งอยู่ใน pod4 แพ็กเก็ตจะไปถึงโหนด 2 ก่อน จากนั้นจึงไปถึงบริดจ์ซึ่งนำไปยังปลายทาง

การสื่อสารภายในโหนด

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

นั่นเป็นวิธีที่พ็อดสื่อสารถึงกันใน Kubernetes ไปที่ส่วนถัดไป

Pod to Service

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

บริการช่วยในการจัดการสถานการณ์นี้ ต่อไปนี้คือคำอธิบายสั้นๆ เกี่ยวกับบริการที่อยู่ใน Kubernetes คุณจึงไม่ต้องสับสน

บริการใน Kubernetes คืออะไร?

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

มีบริการทั้งหมด 4 ประเภทใน Kubernetes พวกเขาเป็น:

• คลัสเตอร์IP
• NodePort
• LoadBalancer
• ชื่อภายนอก

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

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

เมื่อคุณทราบแล้วว่าบริการคืออะไรและมีบริการประเภทใดบ้าง มาพูดคุยกันว่าการสื่อสารระหว่าง Pod to service เกิดขึ้นได้อย่างไร

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

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

ภายนอกสู่การบริการ

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

เมื่อเชื่อมต่อกับเครือข่ายภายนอก Kubernetes สามารถทำหน้าที่สองอย่าง:

• กำหนดเส้นทางการรับส่งข้อมูลจากอินเทอร์เน็ตไปยังเครือข่าย
• กำหนดเส้นทางการรับส่งข้อมูลจากเครือข่ายไปยังอินเทอร์เน็ต

อดีตต้องการเครือข่าย Ingress และหลังต้องการเครือข่าย Egress ลองมาดูที่พวกเขา

ทางเข้า

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

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

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

ทางออก

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

แพ็กเก็ตเริ่มต้นจากเนมสเปซของ Pod และไปที่เนมสเปซรูทผ่านสัตวแพทย์ จากนั้นจะไปที่บริดจ์จากจุดที่เดินทางไปยังบริการเริ่มต้น เนื่องจาก IP ที่ต้องการไปไม่เกี่ยวข้องกับบริดจ์ มันผ่าน iptables ในขณะที่ไปที่รูทเนมสเปซ

อ่าน: ข้อกำหนดเบื้องต้นสำหรับ DevOps: ไม่ใช่สิ่งที่คุณคิด

ตอนนี้เกตเวย์อินเทอร์เน็ตยอมรับเฉพาะที่อยู่ IP ที่เชื่อมต่อกับเครื่องเสมือน และ source pod ของ pocket ไม่ได้เชื่อมต่อกับ VM ดังนั้น iptables จึงทำ NAT ต้นทางและเปลี่ยนแหล่งที่มาของแพ็กเก็ต ตอนนี้ถึงเกตเวย์อินเทอร์เน็ตที่ผ่าน NAT อื่นแล้วเข้าสู่อินเทอร์เน็ตสาธารณะ (ปลายทาง)

และนี่ก็คือ ตอนนี้คุณรู้ทุกอย่างเกี่ยวกับระบบเครือข่าย Kubernetes และส่วนประกอบต่างๆ แล้ว

บทสรุป

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

หากคุณต้องการเรียนรู้และเชี่ยวชาญ Kubernetes, DevOps และอื่นๆ โปรดดูที่ IIIT-B & upGrad's Executive PG Program in Software Development- Specialization in Full Stack Development