สำหรับทรัพยากร Kubernetes แต่ละรายการ คุณสามารถกำหนดค่าข้อกำหนดได้ XNUMX ประเภท ได้แก่ คำขอและขีดจำกัด หัวข้อแรกอธิบายข้อกำหนดขั้นต่ำสำหรับความพร้อมใช้งานของทรัพยากรโหนดอิสระที่จำเป็นในการรันคอนเทนเนอร์หรือพ็อด หัวข้อที่สองจะจำกัดทรัพยากรที่มีอยู่ในคอนเทนเนอร์อย่างเคร่งครัด
เมื่อ Kubernetes กำหนดเวลาพ็อด สิ่งสำคัญมากคือคอนเทนเนอร์จะต้องมีทรัพยากรเพียงพอที่จะทำงานได้อย่างถูกต้อง หากคุณกำลังวางแผนที่จะปรับใช้แอปพลิเคชันขนาดใหญ่บนโหนดที่จำกัดทรัพยากร อาจเป็นไปได้ว่าโหนดจะไม่ทำงานเนื่องจากโหนดมีหน่วยความจำเหลือน้อยหรือใช้พลังงาน CPU หมด ในบทความนี้ เราจะมาดูวิธีที่คุณสามารถแก้ปัญหาการขาดแคลนพลังงานในการประมวลผลโดยใช้คำขอและขีดจำกัดทรัพยากร
คำขอและขีดจำกัดเป็นกลไกที่ Kubernetes ใช้ในการจัดการทรัพยากร เช่น CPU และหน่วยความจำ คำขอคือสิ่งที่ทำให้คอนเทนเนอร์ได้รับทรัพยากรที่ร้องขอ หากคอนเทนเนอร์ร้องขอทรัพยากร Kubernetes จะกำหนดเวลาทรัพยากรบนโหนดที่สามารถจัดเตรียมทรัพยากรได้เท่านั้น การควบคุมขีดจำกัดว่าทรัพยากรที่คอนเทนเนอร์ร้องขอจะไม่เกินค่าที่กำหนด
คอนเทนเนอร์สามารถเพิ่มพลังการประมวลผลได้จนถึงขีดจำกัดเท่านั้น หลังจากนั้นจะถูกจำกัด มาดูกันว่ามันทำงานอย่างไร ดังนั้นจึงมีทรัพยากรสองประเภท - โปรเซสเซอร์และหน่วยความจำ เครื่องกำหนดเวลา Kubernetes ใช้ข้อมูลเกี่ยวกับทรัพยากรเหล่านี้เพื่อดูว่าจะเรียกใช้พ็อดของคุณที่ใด ข้อกำหนดทรัพยากรทั่วไปสำหรับพ็อดมีลักษณะดังนี้
แต่ละคอนเทนเนอร์ในพ็อดสามารถตั้งค่าการสืบค้นและขีดจำกัดของตัวเองได้ ซึ่งเป็นส่วนเสริมทั้งหมด ทรัพยากรตัวประมวลผลถูกกำหนดเป็นมิลลิคอร์ หากคอนเทนเนอร์ของคุณต้องการคอร์เต็มสองคอร์ในการทำงาน คุณต้องตั้งค่าเป็น 2000m หากคอนเทนเนอร์ต้องการพลังงานเพียง 1/4 ของแกน ค่าจะเท่ากับ 250m โปรดทราบว่าหากคุณกำหนดค่าทรัพยากร CPU มากกว่าจำนวนคอร์ของโหนดที่ใหญ่ที่สุด พ็อดของคุณจะไม่ได้รับการกำหนดเวลาให้เริ่มทำงานเลย สถานการณ์ที่คล้ายกันจะเกิดขึ้นหากคุณมี Pod ที่ต้องใช้สี่คอร์ และคลัสเตอร์ Kubernetes ประกอบด้วยเครื่องเสมือนหลักเพียงสองเครื่องเท่านั้น
เว้นแต่ว่าแอปพลิเคชันของคุณได้รับการออกแบบมาโดยเฉพาะเพื่อใช้ประโยชน์จากหลายคอร์ (ต้องคำนึงถึงโปรแกรม เช่น การประมวลผลทางวิทยาศาสตร์ที่ซับซ้อนและการดำเนินการฐานข้อมูล) แนวทางปฏิบัติที่ดีที่สุดคือตั้งค่าคำขอ CPU เป็น 1 หรือต่ำกว่า จากนั้นเรียกใช้แบบจำลองเพิ่มเติมเพื่อให้สามารถปรับขนาดได้ โซลูชันนี้จะทำให้ระบบมีความยืดหยุ่นและเชื่อถือได้มากขึ้น
เมื่อพูดถึงข้อจำกัดของ CPU สิ่งต่างๆ จะน่าสนใจมากขึ้นเนื่องจากถือเป็นทรัพยากรที่สามารถบีบอัดได้ หากแอปพลิเคชันของคุณเริ่มเข้าใกล้ขีดจำกัดพลังงานของโปรเซสเซอร์ Kubernetes จะเริ่มชะลอคอนเทนเนอร์ของคุณโดยใช้การควบคุมปริมาณ CPU เพื่อลดความถี่ของโปรเซสเซอร์ ซึ่งหมายความว่า CPU จะถูกควบคุมปริมาณโดยไม่ตั้งใจ ส่งผลให้แอปพลิเคชันอาจมีประสิทธิภาพแย่ลง แต่กระบวนการจะไม่ถูกยกเลิกหรือนำออกไป
ทรัพยากรหน่วยความจำถูกกำหนดเป็นไบต์ โดยปกติแล้วค่าในการตั้งค่าจะวัดเป็นเมบิไบต์ Mib แต่คุณสามารถตั้งค่าใดก็ได้ตั้งแต่ไบต์ไปจนถึงเพตาไบต์ สถานการณ์เดียวกันนี้มีผลที่นี่เช่นเดียวกับ CPU หากคุณส่งคำขอสำหรับจำนวนหน่วยความจำที่มากกว่าจำนวนหน่วยความจำบนโหนดของคุณ พ็อดนั้นจะไม่ถูกกำหนดเวลาให้ดำเนินการ แต่ต่างจากทรัพยากรของ CPU ตรงที่หน่วยความจำไม่ได้ถูกบีบอัดเนื่องจากไม่มีทางที่จะจำกัดการใช้งานได้ ดังนั้น การดำเนินการของคอนเทนเนอร์จะหยุดทันทีที่เกินหน่วยความจำที่จัดสรรไว้
สิ่งสำคัญคือต้องจำไว้ว่าคุณไม่สามารถกำหนดค่าคำขอที่เกินทรัพยากรที่โหนดของคุณสามารถให้ได้ ดูข้อกำหนดทรัพยากรที่ใช้ร่วมกันสำหรับเครื่องเสมือน GKE ได้ในลิงก์ด้านล่างวิดีโอนี้
ในโลกอุดมคติ การตั้งค่าเริ่มต้นของคอนเทนเนอร์จะเพียงพอที่จะทำให้เวิร์กโฟลว์ทำงานได้อย่างราบรื่น แต่โลกแห่งความเป็นจริงกลับไม่เป็นเช่นนั้น ผู้คนอาจลืมกำหนดค่าการใช้ทรัพยากรได้อย่างง่ายดาย ไม่เช่นนั้นแฮกเกอร์จะตั้งค่าคำขอและข้อจำกัดที่เกินขีดความสามารถที่แท้จริงของโครงสร้างพื้นฐาน เพื่อป้องกันไม่ให้สถานการณ์ดังกล่าวเกิดขึ้น คุณสามารถกำหนดค่าโควต้าทรัพยากร ResourceQuota และ LimitRange ได้
เมื่อสร้างเนมสเปซแล้ว คุณสามารถบล็อกเนมสเปซได้โดยใช้โควต้า ตัวอย่างเช่น หากคุณมีเนมสเปซ prod และ dev รูปแบบก็คือไม่มีโควต้าการใช้งานจริงและมีโควต้าการพัฒนาที่เข้มงวดมาก วิธีนี้ช่วยให้ prod ในกรณีที่มีการรับส่งข้อมูลเพิ่มขึ้นอย่างรวดเร็ว สามารถเข้าครอบครองทรัพยากรที่มีอยู่ทั้งหมดได้ และบล็อกนักพัฒนาอย่างสมบูรณ์
โควต้าทรัพยากรอาจมีลักษณะเช่นนี้ ในตัวอย่างนี้มี 4 ส่วน - เหล่านี้คือบรรทัดล่างสุด 4 บรรทัดของโค้ด
มาดูกันทีละอัน Requests.cpu คือจำนวนคำขอ CPU รวมสูงสุดที่สามารถมาจากคอนเทนเนอร์ทั้งหมดในเนมสเปซ ในตัวอย่างนี้ คุณสามารถมีคอนเทนเนอร์ 50 ตู้ที่มีคำขอ 10 ล้านรายการ ห้าคอนเทนเนอร์ที่มีคำขอ 100 ล้านรายการ หรือเพียงคอนเทนเนอร์เดียวที่มีคำขอ 500 ล้านรายการ ตราบใดที่จำนวน request.cpu ทั้งหมดของเนมสเปซที่กำหนดน้อยกว่า 500m ทุกอย่างจะเรียบร้อยดี
หน่วยความจำที่ร้องขอร้องขอrequest.memoryคือจำนวนคำขอหน่วยความจำรวมสูงสุดที่คอนเทนเนอร์ทั้งหมดในเนมสเปซสามารถมีได้ เช่นเดียวกับในกรณีก่อนหน้านี้ คุณสามารถมีคอนเทนเนอร์ 50 2 mib, คอนเทนเนอร์ 20 mib ห้าคอนเทนเนอร์ หรือคอนเทนเนอร์ 100 mib เดียวได้ ตราบใดที่จำนวนหน่วยความจำทั้งหมดที่ร้องขอในเนมสเปซน้อยกว่า 100 เมบิไบต์
Limits.cpu คือจำนวนพลังงาน CPU รวมกันสูงสุดที่คอนเทนเนอร์ทั้งหมดในเนมสเปซสามารถใช้ได้ เราถือว่านี่เป็นขีดจำกัดของการร้องขอพลังงานของโปรเซสเซอร์
สุดท้ายนี้ Limits.memory คือจำนวนหน่วยความจำที่ใช้ร่วมกันสูงสุดที่คอนเทนเนอร์ทั้งหมดในเนมสเปซสามารถใช้ได้ นี่เป็นขีดจำกัดของการร้องขอหน่วยความจำทั้งหมด
ดังนั้น ตามค่าเริ่มต้น คอนเทนเนอร์ในคลัสเตอร์ Kubernetes จะทำงานโดยใช้ทรัพยากรการประมวลผลไม่จำกัด ด้วยโควต้าทรัพยากร ผู้ดูแลระบบคลัสเตอร์สามารถจำกัดการใช้ทรัพยากรและการสร้างทรัพยากรตามเนมสเปซ ในเนมสเปซ พ็อดหรือคอนเทนเนอร์อาจใช้พลังงาน CPU และหน่วยความจำได้มากเท่ากับที่กำหนดโดยโควต้าทรัพยากรเนมสเปซ อย่างไรก็ตาม มีความกังวลว่าพ็อดหรือคอนเทนเนอร์หนึ่งอาจผูกขาดทรัพยากรที่มีอยู่ทั้งหมด เพื่อป้องกันสถานการณ์นี้ จึงมีการใช้ช่วงขีดจำกัด - นโยบายสำหรับการจำกัดการจัดสรรทรัพยากร (สำหรับพ็อดหรือคอนเทนเนอร์) ในเนมสเปซ
ช่วงขีดจำกัดมีข้อจำกัดที่สามารถ:
- รับประกันการใช้งานทรัพยากรการประมวลผลขั้นต่ำและสูงสุดสำหรับแต่ละโมดูลหรือคอนเทนเนอร์ในเนมสเปซ
- บังคับใช้คำขอจัดเก็บ Starage Request ขั้นต่ำและสูงสุดสำหรับ PersistentVolumeClaim แต่ละรายการในเนมสเปซ
- บังคับใช้ความสัมพันธ์ระหว่างคำขอและขีดจำกัดสำหรับทรัพยากรในเนมสเปซ
- ตั้งค่าคำขอ/ขีดจำกัดเริ่มต้นสำหรับทรัพยากรการประมวลผลในเนมสเปซ และแทรกลงในคอนเทนเนอร์โดยอัตโนมัติขณะรันไทม์
วิธีนี้คุณสามารถสร้างช่วงขีดจำกัดในเนมสเปซของคุณได้ ต่างจากโควต้าที่ใช้กับเนมสเปซทั้งหมด Limit Range ใช้สำหรับแต่ละคอนเทนเนอร์ วิธีนี้สามารถป้องกันไม่ให้ผู้ใช้สร้างคอนเทนเนอร์ขนาดเล็กมากหรือในทางกลับกันขนาดยักษ์ภายในเนมสเปซ Limit Range อาจมีลักษณะเช่นนี้
เช่นเดียวกับในกรณีก่อนหน้านี้สามารถแยกแยะได้ 4 ส่วนที่นี่ มาดูกันทีละอัน
ส่วนเริ่มต้นจะกำหนดขีดจำกัดเริ่มต้นสำหรับคอนเทนเนอร์ในพ็อด หากคุณตั้งค่าเหล่านี้เป็นช่วงสุดขั้ว คอนเทนเนอร์ใดๆ ที่ไม่ได้ตั้งค่าเหล่านี้อย่างชัดเจนจะเป็นไปตามค่าเริ่มต้น
ส่วนคำขอเริ่มต้น defaultRequest กำหนดค่าคำขอเริ่มต้นสำหรับคอนเทนเนอร์ในพ็อด ขอย้ำอีกครั้ง หากคุณตั้งค่าเหล่านี้เป็นช่วงสุดขั้ว คอนเทนเนอร์ใดๆ ที่ไม่ได้ตั้งค่าตัวเลือกเหล่านี้อย่างชัดเจนจะมีค่าเริ่มต้นเป็นค่าเหล่านี้
ส่วนสูงสุดระบุขีดจำกัดสูงสุดที่สามารถตั้งค่าสำหรับคอนเทนเนอร์ในพ็อดได้ ค่าในส่วนเริ่มต้นและขีดจำกัดของคอนเทนเนอร์ไม่สามารถตั้งค่าเกินขีดจำกัดนี้ได้ สิ่งสำคัญคือต้องทราบว่าหากตั้งค่าไว้ที่สูงสุดและไม่มีส่วนเริ่มต้น ค่าสูงสุดจะกลายเป็นค่าเริ่มต้น
ส่วนขั้นต่ำระบุคำขอขั้นต่ำที่สามารถตั้งค่าสำหรับคอนเทนเนอร์ในพ็อด อย่างไรก็ตาม ค่าในส่วนเริ่มต้นและการสืบค้นสำหรับคอนเทนเนอร์ไม่สามารถตั้งค่าต่ำกว่าขีดจำกัดนี้ได้
ขอย้ำอีกครั้งว่า สิ่งสำคัญที่ควรทราบคือหากตั้งค่านี้ไว้ ไม่ใช่ค่าเริ่มต้น จากนั้นค่าต่ำสุดจะกลายเป็นพรอมต์เริ่มต้น
ในที่สุดคำขอทรัพยากรเหล่านี้จะถูกใช้โดยตัวกำหนดเวลา Kubernetes เพื่อดำเนินการภาระงานของคุณ เพื่อให้คุณสามารถกำหนดค่าคอนเทนเนอร์ได้อย่างถูกต้อง สิ่งสำคัญมากคือต้องเข้าใจวิธีการทำงาน สมมติว่าคุณต้องการเรียกใช้หลายพ็อดในคลัสเตอร์ของคุณ หากข้อกำหนดเฉพาะของพ็อดนั้นถูกต้อง กำหนดการของ Kubernetes จะใช้การปรับสมดุลแบบ Round Robin เพื่อเลือกโหนดเพื่อรันปริมาณงาน
Kubernetes จะตรวจสอบว่าโหนด 1 มีทรัพยากรเพียงพอที่จะตอบสนองคำขอจากคอนเทนเนอร์พ็อดหรือไม่ และหากไม่มี ก็จะย้ายไปยังโหนดถัดไป หากไม่มีโหนดใดในระบบที่สามารถตอบสนองคำขอได้ พ็อดจะเข้าสู่สถานะรอดำเนินการ GKE ใช้ฟีเจอร์ Google Kubernetes Engine เช่น การปรับขนาดโหนดอัตโนมัติ ตรวจจับสถานะรอได้โดยอัตโนมัติและสร้างโหนดเพิ่มเติมอีกหลายโหนด
หากความจุโหนดของคุณหมดในเวลาต่อมา การปรับขนาดอัตโนมัติจะลดจำนวนโหนดเพื่อช่วยคุณประหยัดเงิน นี่คือสาเหตุที่ Kubernetes กำหนดเวลาพ็อดตามคำขอ อย่างไรก็ตาม ขีดจำกัดอาจสูงกว่าคำขอ และในบางกรณี โหนดอาจใช้ทรัพยากรจนหมดจริงๆ เราเรียกสภาวะนี้ว่าภาวะมีความมุ่งมั่นมากเกินไป
อย่างที่ฉันบอกไปแล้ว เมื่อพูดถึง CPU Kubernetes จะเริ่มจำกัดพ็อด แต่ละพ็อดจะได้รับมากเท่าที่ร้องขอ แต่หากไม่ถึงขีดจำกัด การควบคุมปริมาณจะเริ่มมีผล
เมื่อพูดถึงทรัพยากรหน่วยความจำ Kubernetes ถูกบังคับให้ตัดสินใจว่าจะลบพ็อดใดและควรเก็บไว้จนกว่าคุณจะเพิ่มทรัพยากรระบบ มิฉะนั้นระบบทั้งหมดจะเสียหาย
ลองจินตนาการถึงสถานการณ์ที่คุณมีเครื่องที่มีหน่วยความจำไม่เพียงพอ Kubernetes จะจัดการเรื่องนั้นได้อย่างไร
Kubernetes จะค้นหาพ็อดที่ใช้ทรัพยากรมากกว่าที่ขอ ดังนั้นหากคอนเทนเนอร์ของคุณไม่มี Requests เลย นั่นหมายความว่าคอนเทนเนอร์เหล่านี้เริ่มใช้เกินกว่าที่ขอ เพียงเพราะพวกเขาไม่ได้ขออะไรเลย! คอนเทนเนอร์ดังกล่าวกลายเป็นตัวเลือกหลักในการปิดระบบ ตัวเลือกถัดไปคือคอนเทนเนอร์ที่ตอบสนองคำขอทั้งหมดของตนแต่ยังต่ำกว่าขีดจำกัดสูงสุด
ดังนั้น หาก Kubernetes พบพ็อดหลายตัวที่เกินพารามิเตอร์คำขอ ระบบจะจัดเรียงพ็อดเหล่านั้นตามลำดับความสำคัญ จากนั้นจึงลบพ็อดที่มีลำดับความสำคัญต่ำสุดออก หากพ็อดทั้งหมดมีลำดับความสำคัญเท่ากัน Kubernetes จะยุติพ็อดเหล่านั้นที่เกินคำขอมากกว่าพ็อดอื่นๆ
ในกรณีที่เกิดขึ้นไม่บ่อยนัก Kubernetes อาจยกเลิกพ็อดที่ยังอยู่ในขอบเขตคำขอ กรณีนี้อาจเกิดขึ้นเมื่อส่วนประกอบของระบบที่สำคัญ เช่น Kubelet agent หรือ Docker เริ่มใช้ทรัพยากรมากกว่าที่สงวนไว้
ดังนั้น ในช่วงแรกๆ ของบริษัทขนาดเล็ก คลัสเตอร์ Kubernetes สามารถทำงานได้ดีโดยไม่ต้องตั้งค่าคำขอทรัพยากรและข้อจำกัด แต่เมื่อทีมและโครงการของคุณเริ่มมีขนาดใหญ่ขึ้น คุณก็เสี่ยงที่จะประสบปัญหาในส่วนนี้ การเพิ่มคำค้นหาและข้อจำกัดให้กับโมดูลและเนมสเปซของคุณต้องใช้ความพยายามเป็นพิเศษเพียงเล็กน้อย และช่วยลดความยุ่งยากได้มาก
โฆษณาบางส่วน🙂
ขอบคุณที่อยู่กับเรา คุณชอบบทความของเราหรือไม่? ต้องการดูเนื้อหาที่น่าสนใจเพิ่มเติมหรือไม่ สนับสนุนเราโดยการสั่งซื้อหรือแนะนำให้เพื่อน , อะนาล็อกที่ไม่เหมือนใครของเซิร์ฟเวอร์ระดับเริ่มต้นซึ่งเราคิดค้นขึ้นเพื่อคุณ: (ใช้ได้กับ RAID1 และ RAID10 สูงสุด 24 คอร์ และสูงสุด 40GB DDR4)
Dell R730xd ถูกกว่า 2 เท่าในศูนย์ข้อมูล Equinix Tier IV ในอัมสเตอร์ดัม? ที่นี่ที่เดียวเท่านั้น ในเนเธอร์แลนด์! Dell R420 - 2x E5-2430 2.2Ghz 6C 128GB DDR3 2x960GB SSD 1Gbps 100TB - จาก $99! อ่านเกี่ยวกับ
ที่มา: will.com