มีวรรณกรรมอ้างอิงมากมายบนอินเทอร์เน็ต แต่บางครั้งคำแนะนำที่ง่ายที่สุดก็มีค่าที่สุด ทีม แปลแล้ว ซึ่งผู้เขียนบทความรวบรวมหลังจากทำงานกับ Kubernetes มาหนึ่งปี เคล็ดลับไม่ได้จัดเรียงตามความสำคัญ แต่เราคิดว่าทุกคนจะพบสิ่งที่มีประโยชน์สำหรับตนเอง
คำสั่งที่ง่ายที่สุดในการทำงานกับ Kubernetes
เริ่มต้นด้วยการดำเนินการที่ง่ายและมีประโยชน์มากที่สุดในการทำงานกับ Kubernetes คำสั่งต่อไปนี้ช่วยให้คำสั่งสมบูรณ์ kubectl ในเปลือกทุบตี:
echo "source <(kubectl completion bash)" >> ~/.bashrc
ป้อนอัตโนมัติ kubectl จะถูกเขียนลงในไฟล์ .bashrc และจะเปิดใช้งานโดยอัตโนมัติทุกครั้งที่สตาร์ทเชลล์ ซึ่งจะช่วยเร่งความเร็วในการพิมพ์คำสั่งและพารามิเตอร์ขนาดยาว เช่น all-namespaces. รายละเอียดเพิ่มเติมใน .
หน่วยความจำเริ่มต้นและขีดจำกัดของ CPU ในเนมสเปซ
หากแอปพลิเคชันเขียนไม่ถูกต้อง ตัวอย่างเช่น แอปพลิเคชันจะเปิดการเชื่อมต่อใหม่ไปยังฐานข้อมูลทุกวินาทีแต่ไม่เคยปิดเลย แสดงว่าคลัสเตอร์มีหน่วยความจำรั่ว และหากแอปพลิเคชันไม่ได้กำหนดขีดจำกัดหน่วยความจำไว้ในระหว่างการปรับใช้ ก็อาจทำให้โหนดล้มเหลวได้
เพื่อป้องกันปัญหานี้ Kubernetes อนุญาตให้คุณตั้งค่าข้อจำกัดเริ่มต้นตามเนมสเปซแต่ละราย เขียนไว้ในไฟล์ yaml สำหรับเนมสเปซเฉพาะ นี่คือตัวอย่างของไฟล์ดังกล่าว:
apiVersion: v1
kind: LimitRange
metadata:
name: mem-limit-range
spec:
limits:
- default:
memory: 512Mi
defaultRequest:
memory: 256Mi
type: Container
สร้าง yaml ดังกล่าวและนำไปใช้กับเนมสเปซใดก็ได้ ตัวอย่างเช่น ไปที่เนมสเปซ limit-example. ขณะนี้คอนเทนเนอร์ใดๆ ที่ใช้งานในเนมสเปซนี้จะมีขีดจำกัดที่ 512Mi เว้นแต่จะมีการตั้งค่าขีดจำกัดอื่นๆ เพิ่มเติมสำหรับคอนเทนเนอร์นี้
การรวบรวมขยะใน Kubernetes เวอร์ชันเก่า
Kubelet โดยค่าเริ่มต้นจะเริ่มเก็บขยะเมื่อใด var/lib/docker ใช้พื้นที่ดิสก์ที่มีอยู่ 90% อย่างไรก็ตาม วิธีนี้ดีมาก จนกระทั่ง Kubernetes 1.7 ไม่มีการจำกัดค่าเริ่มต้นเกี่ยวกับจำนวน inode ที่ใช้ ซึ่งสอดคล้องกับจำนวนไฟล์ในระบบไฟล์
อาจเป็นภาชนะของคุณ var/lib/docker อาจใช้พื้นที่ดิสก์เพียง 50% แต่อาจใช้ inode ไม่เพียงพอ ซึ่งจะทำให้เกิดปัญหากับผู้ปฏิบัติงาน
ใน kubelet เวอร์ชันเก่าตั้งแต่ 1.4 ถึง 1.6 คุณจะต้องเพิ่มแฟล็กนี้:
--eviction-hard
=memory.available<100Mi,nodefs.available<10%,nodefs.inodesFree<5%
ในเวอร์ชัน 1.7 และใหม่กว่า แฟล็กนี้จะถูกตั้งค่าตามค่าเริ่มต้น อย่างไรก็ตาม เวอร์ชันก่อนหน้าไม่ได้ตรวจสอบขีดจำกัดของไอโหนด
Minikube... Kubernetes ท้องถิ่นขนาดเล็กแต่ทรงพลัง
Minikube เป็นวิธีที่ง่ายที่สุดในการรันคลัสเตอร์ Kubernetes ในเครื่อง เปิดตัวด้วยคำสั่งง่ายๆ:
minikube start
การรันคำสั่งนี้ส่งผลให้คลัสเตอร์ Kubernetes จริงทำงานบนเครื่องของคุณ
เคล็ดลับคือวิธีสร้างแอปพลิเคชันและรันภายในคลัสเตอร์นั้น อิมเมจ Docker จะถูกสร้างขึ้นบนคอมพิวเตอร์ของคุณ ไม่ใช่บนคลัสเตอร์ เว้นแต่จะได้รับคำแนะนำเป็นพิเศษ
หากต้องการบังคับให้ Docker พุชอิมเมจไปยังคลัสเตอร์ Kubernetes ในเครื่อง เครื่องนักเทียบท่าจะได้รับคำสั่งต่อไปนี้:
eval $(minikube docker-env)
ตอนนี้เราสามารถสร้างแอปพลิเคชันบนคลัสเตอร์ Kubernetes ในเครื่องได้แล้ว
อย่าให้ kubectl เข้าถึงทุกคนได้
สิ่งนี้ดูเหมือนจะชัดเจน แต่ถ้าหลายทีมใช้คลัสเตอร์เดียวกันสำหรับแอปพลิเคชันของพวกเขา (ซึ่งเป็นสิ่งที่ Kubernetes สร้างขึ้นเพื่อ) คุณไม่ควรให้ทุกคนเท่านั้น kubectl. เป็นการดีกว่าที่จะแยกคำสั่ง กำหนดเนมสเปซของตนเองให้กับแต่ละคำสั่ง และจำกัดการเข้าถึงโดยใช้นโยบาย RBAC
คุณอาจสับสนได้โดยการกำหนดสิทธิ์ในการเข้าถึง อ่าน สร้าง ลบ และดำเนินการอื่นๆ สำหรับแต่ละพ็อด แต่สิ่งสำคัญคือการจำกัดการเข้าถึงความลับโดยอนุญาตเฉพาะผู้ดูแลระบบเท่านั้น ด้วยวิธีนี้เราจะแยกแยะระหว่างผู้ที่สามารถดูแลคลัสเตอร์และผู้ที่สามารถปรับใช้กับคลัสเตอร์ได้
จัดการงบประมาณพ็อด
จะแน่ใจได้อย่างไรว่าจะไม่มีการหยุดทำงานสำหรับแอปพลิเคชันในคลัสเตอร์ Kubernetes PodDisruptionBudget และ PodDisruptionBudget อีกครั้ง
คลัสเตอร์ได้รับการอัปเดตเป็นระยะและโหนดจะว่างเปล่า ไม่มีอะไรหยุดนิ่ง นั่นคือความจริง การปรับใช้ทุกครั้งที่มีมากกว่าหนึ่งอินสแตนซ์ควรมี PDB (PodDisruptionBudget) มันถูกสร้างขึ้นในไฟล์ yaml ธรรมดาที่ใช้กับคลัสเตอร์ พื้นที่ครอบคลุมของ PDB เฉพาะนั้นถูกกำหนดโดยตัวเลือกป้ายกำกับ
หมายเหตุ: งบประมาณ PDB จะถูกนำมาพิจารณาเฉพาะเมื่อการละเมิดงบประมาณสามารถย้อนกลับได้ (). ในสถานการณ์เช่นฮาร์ดแวร์ขัดข้อง PDB จะไม่ทำงาน
ตัวอย่าง PDB:
apiVersion: policy/v1beta1
kind: PodDisruptionBudget
metadata:
name: app-a-pdb
spec:
minAvailable: 2
selector:
matchLabels:
app: app-a
พารามิเตอร์หลักสองตัวคือ matchLabels и minAvailable. พารามิเตอร์แรกระบุว่าแอปพลิเคชันใดที่จะใช้งบประมาณ ตัวอย่างเช่น หากฉันมีการปรับใช้งานที่มีป้ายกำกับ app: app-a и app: app-bจากนั้น PDB นี้จะใช้กับอันแรกเท่านั้น
พารามิเตอร์ minAvailable นำมาพิจารณาเมื่อทำการล้าง (ทำความสะอาด) โหนด ตัวอย่างเช่น ในตัวอย่างของเรา ในระหว่างการล้างข้อมูล อินสแตนซ์ทั้งหมดจะถูกไล่ออก app: app-aยกเว้นสอง
สิ่งนี้ช่วยให้คุณควบคุมจำนวนอินสแตนซ์ของแอปพลิเคชันที่ควรทำงานในเวลาใดก็ตาม
การตรวจสอบสุขภาพของแอปพลิเคชัน
การตรวจสอบดังกล่าวสามารถทำได้สองวิธี: ใช้การทดสอบความพร้อมหรือความมีชีวิตชีวา
การสอบสวนครั้งแรก (ความพร้อม) กำหนดความพร้อมของคอนเทนเนอร์ในการรับปริมาณข้อมูล
ส่วนที่สอง (ความมีชีวิตชีวา) แสดงว่าคอนเทนเนอร์นั้นแข็งแรงดีหรือจำเป็นต้องรีสตาร์ท
การกำหนดค่าที่เกี่ยวข้องจะถูกเพิ่มลงใน yaml เพื่อการใช้งาน ที่นั่นคุณสามารถระบุการหมดเวลา เวลาล่าช้า และจำนวนครั้งในการลองใหม่ได้ ดูรายละเอียดเพิ่มเติมเกี่ยวกับพวกเขา .
แท็กมีอยู่ทั่วไป
ป้ายกำกับเป็นหนึ่งในแนวคิดพื้นฐานใน Kubernetes ช่วยให้ออบเจ็กต์สามารถสื่อสารกันได้อย่างอิสระ รวมถึงสร้างแบบสอบถามตามป้ายกำกับ ใน Kubernetes คุณสามารถไปที่ไคลเอนต์และดูเหตุการณ์สำหรับแท็กเฉพาะได้
คุณสามารถทำอะไรได้เกือบทุกอย่างด้วยแท็ก แต่ตัวอย่างที่ดีคือการสร้างสภาพแวดล้อมหลายรายการเพื่อรันโปรแกรมบนคลัสเตอร์เดียวกัน
สมมติว่าคุณใช้คลัสเตอร์เดียวกันสำหรับ dev и qa. ซึ่งหมายความว่าคุณสามารถมีใบสมัครได้ app-aทำงานได้พร้อมกันทั้งสองสภาพแวดล้อม qa и dev. ในกรณีนี้ เราสามารถเข้าถึงอินสแตนซ์ของแอปพลิเคชันแยกต่างหากในสภาพแวดล้อมเฉพาะโดยการระบุพารามิเตอร์ที่เหมาะสม environment. ตัวอย่างเช่น app: app-a и environment: dev สำหรับสภาพแวดล้อมเดียวและ app: app-a и environment: qa สำหรับอันที่สอง
ซึ่งช่วยให้คุณเข้าถึงทั้งสองอินสแตนซ์ของแอปพลิเคชันได้ เช่น เพื่อทำการทดสอบพร้อมกัน
ได้รับการจัด
Kubernetes เป็นระบบที่ทรงพลังมาก แต่ในที่สุดระบบใดก็ตามก็สามารถจมอยู่กับกระบวนการที่มากเกินไปได้ Kubelet รันกระบวนการทั้งหมดและตรวจสอบที่คุณระบุ รวมถึงกระบวนการของตัวเองด้วย
แน่นอนว่าบริการที่ไม่มีผู้ดูแลจะไม่ทำให้ระบบช้าลง และ Kubernetes ได้รับการออกแบบมาเพื่อขยายขนาดตั้งแต่เริ่มต้น แต่ถ้าแทนที่จะเป็นบริการหนึ่งล้านรายการปรากฏขึ้น kubelet ก็เริ่มสำลัก
หากคุณลบการปรับใช้ (คอนเทนเนอร์ รูปภาพ หรืออะไรก็ตาม) ด้วยเหตุผลบางประการ เพียงอย่าลืมทำการล้างข้อมูลให้เสร็จสิ้น
พบกับโก
เราบันทึกคำแนะนำหลักไว้เป็นครั้งสุดท้าย เรียนรู้ภาษาการเขียนโปรแกรม Go
Kubernetes ได้รับการพัฒนาใน Go ส่วนขยายทั้งหมดเขียนด้วย Go และไลบรารีไคลเอ็นต์ client-go ก็ได้รับการสนับสนุนอย่างเป็นทางการเช่นกัน
มันสามารถนำไปใช้ในสิ่งที่แตกต่างและน่าสนใจ เช่น เพื่อขยายระบบ Kubernetes ให้เป็นรสนิยมของคุณ ดังนั้น คุณสามารถใช้โปรแกรมของคุณเองเพื่อรวบรวมข้อมูล ปรับใช้แอปพลิเคชัน หรือเพียงแค่ล้างคอนเทนเนอร์ก็ได้
การเรียนรู้ภาษาการเขียนโปรแกรม Go และการเรียนรู้ Client-Go อาจเป็นคำแนะนำที่สำคัญที่สุดที่คุณสามารถมอบให้กับผู้ใช้ Kubernetes ใหม่ได้
มีอะไรให้อ่านอีก:
- .
- ?
- .
ที่มา: will.com