ปรับปรุงการตรวจสอบคลัสเตอร์ด้วยการแมปเครือข่ายใน Grafana

เจาะลึกในการรับแผนที่เครือข่ายและเชื่อมโยง IP กับปริมาณงานของคลัสเตอร์เพื่อเร่งการดีบัก

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

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

การตรวจสอบคลัสเตอร์คืออะไร?

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

ด้วยคลัสเตอร์ที่สร้างตัววัดเหล่านี้หลายล้านตัวต่อวัน ความท้าทายใหญ่สองประการรออยู่ข้างหน้า: ประการแรก ระบบตรวจสอบแบบเดิมๆ หลายระบบจำเป็นต้องตรวจสอบตัววัดจำนวนมากที่มาจากคลัสเตอร์ Kubernetes ประการที่สอง เป็นการยากที่จะแยกแยะตัวชี้วัดที่สำคัญที่สุดออกจาก “ข้อมูลที่เกะกะ”

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

การตรวจสอบคลัสเตอร์และการแมปเครือข่าย

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

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

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

Caretta เป็นเครื่องมือโอเพ่นซอร์สที่ให้การตรวจสอบเครือข่ายโดยการรวบรวมข้อมูลทรัพยากรคลัสเตอร์และประมวลผลข้อมูลเคอร์เนลด้วย eBPF (ตัวกรอง Berkeley Packet แบบขยาย) การส่งตัววัดที่มีป้ายกำกับผ่าน Prometheus และการแสดงข้อมูลเป็นภาพบนแดชบอร์ด Grafana

ประกอบด้วย K8sIPResolver ที่ใช้งานโดยแพ็คเกจ client-go และผู้ติดตามพร้อมเซิร์ฟเวอร์การวัดที่ส่งข้อมูล eBPF

K8sIPResolver ตรวจสอบทรัพยากรคลัสเตอร์เก้าประเภทแบบไดนามิก (pods, node, replicaset, daemonset, statefulset, job, service, deployment, cronjob) ด้วยกลไกการรับชมไคลเอนต์ go รวบรวมและวิเคราะห์ข้อมูล เช่น ที่อยู่ IP บันทึกข้อมูลเหล่านั้นใน แคช LRU และถ่ายภาพสแนปช็อต

eBPF คืออะไร?

ตัววัดใช้ eBPF เพื่อรวบรวมข้อมูลเครือข่ายและส่งตัววัดไปยัง Prometheus หลังจากติดป้ายกำกับตามข้อมูลทรัพยากรข้างต้น

อาจกล่าวได้ว่า eBPF นำประสิทธิภาพสูงมาสู่ Caretta

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

eBPF ทำงานอย่างไรใน Caretta

ใน Caretta โพรบที่เกี่ยวข้องได้รับการปรับแต่งสำหรับการติดตามข้อมูลเครือข่าย เช่น tcp_data_queue และ inet_sock_set_state และ bpfobject ถูกสร้างขึ้นด้วยแพ็คเกจ cilium ebpf เพื่อรวบรวมข้อมูลลิงก์เครือข่ายอย่างรวดเร็ว

คุณสามารถค้นหา "รหัส" สำหรับสิ่งนี้ได้ใน GitHub

eBPF ดำเนินการในสองขั้นตอน

อย่างแรกคือ โค้ด นั่นคือการปรับแต่งโครงสร้างข้อมูลและอัลกอริธึม: การแยกวิเคราะห์ข้อมูล TCP, ถุงเท้า และบทบาทใน eBPF เก็บไว้ในแผนที่และสร้างโพรบในโค้ด Go

ประการที่สอง จัดทำแพ็กเกจ eBPF ด้วยโค้ด Go ด้วยคำสั่งต่อไปนี้ใน Makefile และปรับใช้

generate_ebpf: ${BPF2GO_BINARY}_${BPF2GO_VERSION} \
    download_libbpf_headers
 go mod vendor
 (cd ${REPODIR}/pkg/tracing && \
  GOPACKAGE=tracing ${REPODIR}/${BPF2GO_BINARY}_${BPF2GO_VERSION} \
  -cc "${BPF_CLANG}" -cflags "${BPF_CFLAGS}"  \
  -target native bpf \
  ebpf/caretta.bpf.c --)

คาเร็ตต้ากับกราฟาน่า

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

Caretta ทำงานร่วมกับ Grafana โดยเพิ่มแผนภูมิหางเสือและแดชบอร์ดลงในแหล่งที่มาเพื่อให้ผู้ใช้ได้รับภาพที่คาดหวังได้อย่างรวดเร็ว แผงควบคุมมีสี่แผง: ServiceMap, พอร์ตที่ใช้งานอยู่, ปริมาณงานปริมาณงานสูงสุด และการเชื่อมต่อปริมาณงานสูงสุด ซึ่งทั้งหมดได้รับจากการรวมกลุ่มที่แตกต่างกันโดยอิงตามตัววัด caretta_links_observed

ตัวอย่างเช่น นิพจน์ Top Throughput Workloads คือปริมาณงาน 8 อันดับแรกภายใน sum หลัง group ตาม client_name

topk(8, sum by (client_name) ((rate(caretta_links_observed{client_namespace=~\"$namespace\", client_kind=~\"$kind\", client_name=~\"$workload\", server_port=~\"$port\"}[$__range:$__interval]))))

แผงทั้งสี่นี้ตอบสนองความต้องการพื้นฐานของเราในการตรวจสอบการแมปเครือข่ายปริมาณงาน และเรายังปรับแต่งคำค้นหาหรือระนาบที่เกี่ยวข้องเพื่อรับข้อมูลเพิ่มเติมได้อีกด้วย

พวกเขาทำงานร่วมกันอย่างไร

มาดูการสาธิตคาเร็ตต้าแบบสั้นๆ กัน

ติดตั้งคลัสเตอร์ชนิด หากคุณใช้เครื่อง Mac จำเป็นต้องมี Linux VM

คลัสเตอร์ชนิดเริ่มต้นมีเพียงโหนดเดียวเท่านั้น มาสร้างคลัสเตอร์ที่มีโหนดผู้ปฏิบัติงานสามโหนดด้วยการกำหนดค่าต่อไปนี้เพื่อแสดงข้อมูลได้ดีขึ้น

kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
nodes:
- role: control-plane
- role: worker
- role: worker
- role: worker

จากนั้นสร้างคลัสเตอร์ด้วยการกำหนดค่าด้านบน

shell
kind create cluster --config=config.yaml
kubectl cluster-info --context kind-kind

หากต้องการติดตั้ง Caretta คุณต้องติดตั้ง helm CLI ในเครื่องก่อน

helm repo add groundcover https://helm.groundcover.com/
helm repo update
helm install caretta --namespace caretta --create-namespace groundcover/caretta

ตรวจสอบสถานะการทำงานของพ็อด Caretta ด้วย kubectl get pods -ncaretta

หมายเหตุ: คุณต้องใช้ Docker เวอร์ชันล่าสุด (4.13) มิฉะนั้น รหัส eBPF จะล้มเหลวในการดำเนินการ และคุณจะได้รับพร้อมท์ข้อผิดพลาดต่อไปนี้:

Couldn't load probes - error loading BPF objects from go-side. field HandleSockSetState: program handle_sock_set_state: apply CO-RE relocations: no BTF found for kernel version 5.15.49-linuxkit: not supported

ส่งต่อพอร์ตไปยัง Grafana ในเครื่องบนพอร์ต 3000

kubectl port-forward --namespace caretta caretta-grafana-5b8594ddb8-cxmvr 3000:3000

ตอนนี้ เราสามารถดูสถานะการแมปเครือข่ายของคลัสเตอร์ได้ในเบราว์เซอร์ localhost:3000 หากไม่มีการปรับใช้และบริการเพื่อแสดงข้อมูลในคลัสเตอร์ตั้งแต่เริ่มต้น เราสามารถติดตั้ง hello-app ได้

kubectl create deployment hello-app --image=hello-repo/hello-app:v2
# expose 
kubectl expose deployment hello-app --name=hello-app-service --type=LoadBalancer --port 80 --target-port 8080

จากนั้นข้อมูลเครือข่ายเฉพาะจะแสดงใน Grafana

โดยรวมแล้ว Caretta มีประสิทธิภาพมากในการสร้างการแมปเครือข่าย ยกเว้นข้อจำกัดประการหนึ่ง นั่นคือ eBPF รองรับเฉพาะ Linux เท่านั้น ไม่ใช่ Mac จำเป็นต้องปรับปรุงการพัฒนา eBPF บน Mac M1

บทสรุป

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

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

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