מתכנן משאבים ל-Kubernetes
הזינו את גודל ה-node ואת העומסים (replicas, requests ו-limits של CPU וזיכרון), או הדביקו את ה-manifests שלהם. תקבלו את מספר ה-nodes, כמה הם מלאים, מה ממוקם בכל אחד ואילו pods לא נכנסים, כשכל תקורה מוצגת עם המקור שלה.
עומסים
לכל pod. 1000 millicores = 1 vCPU; 0 פירושו לא הוגדר.
עד 50 עומסים.
ייבוא מ-manifests
הדביקו YAML של Kubernetes: Deployments, StatefulSets, DaemonSets, ReplicaSets, Jobs ו-Pods, כמה מסמכים מופרדים בשורת ---. רק ה-kind, השם, ה-replicas וה-requests וה-limits של CPU וזיכרון של ה-containers נקראים.
השורות שאתם מייבאים הופכות לקלט רגיל: השמות והמספרים שלהן נכנסים לקישור השיתוף כמו כל דבר שאתם מקלידים. ה-YAML עצמו לא נשמר.
הדביקו את הטקסט, או בחרו קובץ מהמחשב. עד 256 KiB.
0 מתוך 256 KiB
תוצאה
- Nodes
- 4
- CPU מבוקש מתוך ה-allocatable
- 67.2%
- זיכרון מבוקש מתוך ה-allocatable
- 29.7%
- CPU שאפשר להקצות לכל node
- 3.72 vCPU
- זיכרון שאפשר להקצות לכל node
- 12.91 GiB
- Pods שמוקמו
- 8
- Pods שלא נכנסים לאף node
- 0
| שורה | ערך | הנחות בשימוש |
|---|---|---|
| CPU של node | 4 vCPU | |
| CPU: שמירה ל-kubelet ולמערכת | 0.08 vCPU |
|
| CPU: DaemonSets של המערכת | 0.2 vCPU |
|
| CPU: העומסים שלכם בכל node | 0 vCPU | |
| CPU שאפשר להקצות ל-pods, לכל node | 3.72 vCPU |
|
| זיכרון של node | 16 GiB | |
| זיכרון: שמירה ל-kubelet ולמערכת | 2.6 GiB |
|
| זיכרון: סף פינוי | 0.1 GiB |
|
| זיכרון: DaemonSets של המערכת | 0.39 GiB |
|
| זיכרון: העומסים שלכם בכל node | 0 GiB | |
| זיכרון שאפשר להקצות ל-pods, לכל node | 12.91 GiB |
|
| מקומות ל-pods בכל node | 110 |
|
| CPU שה-pods מבקשים | 7.5 vCPU | |
| זיכרון שה-pods מבקשים | 11.5 GiB | |
| nodes שה-pods צריכים (first-fit decreasing) | 3 |
|
| nodes רזרביים ל-HA | 1 |
|
הנחות
כל מספר שהתוצאה משתמשת בו ולא הזנתם. אפשר לשנות כל אחד מהם כך שיתאים למקרה שלכם.
- %
המדרגות ש-GKE מפרסם ל-node pools שנוצרו בגרסה 1.36 ומטה: CPU 6% מהליבה הראשונה, 1% מהשנייה, 0.5% משתי הבאות ו-0.25% מעל ארבע; זיכרון 255 MiB מתחת ל-1 GiB, אחרת 25% מ-4 ה-GiB הראשונים, 20% מ-4 הבאים, 10% מ-8 הבאים, 6% עד 128 GiB ו-2% מעל. 100% מחיל אותן כפי שפורסמו; פלטפורמות אחרות שומרות אחרת, ו-0% לא שומר כלום (ברירת המחדל של Kubernetes עצמו).
מקור · - MiB
סף הפינוי הקשיח של ה-kubelet כברירת מחדל ב-Linux, memory.available<100Mi: ה-pods מפונים לפני שהזיכרון הפנוי של ה-node יורד מתחתיו, ולכן הוא לא allocatable.
מקור · - הנחהmillicores
מה שהסוכנים של הקלסטר עצמו מבקשים בכל node: ה-network plugin (CNI), kube-proxy, סוכן לוגים וסוכן מדדים. משתנה לפי פלטפורמה ותוספים: אפשר לקרוא אותו ב-kubectl describe node.
אין מקור: זו הנחה שלנו. שנו אותה אם אתם מכירים את המקרה שלכם. - הנחהMiB
הזיכרון שאותם סוכנים מבקשים בכל node.
אין מקור: זו הנחה שלנו. שנו אותה אם אתם מכירים את המקרה שלכם. Kubernetes מתוכנן לעד 110 pods ל-node, ברירת המחדל של maxPods ב-kubelet. חלק מהפלטפורמות המנוהלות קובעות מספר אחר.
מקור ·- הנחה
node אחד יותר ממה שה-pods צריכים (N+1): כש-node נופל או מתרוקן לשדרוג, יש לאן להעביר את ה-pods שלו. 0 מתכנן בלי נפילה.
אין מקור: זו הנחה שלנו. שנו אותה אם אתם מכירים את המקרה שלכם.
מה שהזנתם וההנחות ששיניתם נשמרים בקישור של העמוד, אחרי ה-#.
אזהרות
- worker: limit של CPU בלי request. Kubernetes משתמש ב-limit בתור ה-request, ולכן הוא נספר לפי ה-limit.
Nodes
כל node עם ה-pods ש-first-fit decreasing מיקם בו, וכמה מה-CPU והזיכרון שאפשר להקצות בו הם מבקשים.
- Node 1CPU 3.5 vCPU מתוך 3.72 vCPU · זיכרון 6.5 GiB מתוך 12.91 GiB · 3 podsweb × 1, api × 1, postgres × 1
- Node 2CPU 3.5 vCPU מתוך 3.72 vCPU · זיכרון 4.5 GiB מתוך 12.91 GiB · 4 podsweb × 1, api × 1, worker × 2
- Node 3CPU 0.5 vCPU מתוך 3.72 vCPU · זיכרון 0.5 GiB מתוך 12.91 GiB · 1 podsweb × 1
- Node רזרבי 1 (HA)ריק: מקום ל-pods של node שנופל או מתרוקן.
לקחת את התכנון איתכם
התכנון כקובץ Markdown: גודל ה-node, העומסים, התוצאה, האזהרות, כל node, כל הנחה עם המקור או הסימון שלה, והקישור שמשחזר אותו.
# מתכנן משאבים ל-Kubernetes
הערכה לפי ההנחות שמפורטות למטה, לא מדידה ולא התחייבות.
אין מקור: זו הנחה שלנו. שנו אותה אם אתם מכירים את המקרה שלכם.
## מה שהזנתם
- vCPU לכל node: 4
- זיכרון לכל node (GiB): 16
- web: Replicas 3, CPU request (millicores) 500, CPU limit (millicores) 1000, Memory request (MiB) 512, Memory limit (MiB) 1024
- api: Replicas 2, CPU request (millicores) 1000, CPU limit (millicores) 2000, Memory request (MiB) 2048, Memory limit (MiB) 2048
- worker: Replicas 2, CPU request (millicores) 0, CPU limit (millicores) 1000, Memory request (MiB) 1024, Memory limit (MiB) 0
- postgres: Replicas 1, CPU request (millicores) 2000, CPU limit (millicores) 0, Memory request (MiB) 4096, Memory limit (MiB) 4096
## תוצאה
- Nodes: 4
- CPU מבוקש מתוך ה-allocatable: 67.2%
- זיכרון מבוקש מתוך ה-allocatable: 29.7%
- CPU שאפשר להקצות לכל node: 3.72 vCPU
- זיכרון שאפשר להקצות לכל node: 12.91 GiB
- Pods שמוקמו: 8
- Pods שלא נכנסים לאף node: 0
## אזהרות
- worker: limit של CPU בלי request. Kubernetes משתמש ב-limit בתור ה-request, ולכן הוא נספר לפי ה-limit.
## Nodes
- Node 1: CPU 3.5 vCPU מתוך 3.72 vCPU · זיכרון 6.5 GiB מתוך 12.91 GiB · 3 pods (web × 1, api × 1, postgres × 1)
- Node 2: CPU 3.5 vCPU מתוך 3.72 vCPU · זיכרון 4.5 GiB מתוך 12.91 GiB · 4 pods (web × 1, api × 1, worker × 2)
- Node 3: CPU 0.5 vCPU מתוך 3.72 vCPU · זיכרון 0.5 GiB מתוך 12.91 GiB · 1 pods (web × 1)
- Node רזרבי 1 (HA): ריק: מקום ל-pods של node שנופל או מתרוקן.
## פירוט
| שורה | ערך | הנחות בשימוש |
| --- | --- | --- |
| CPU של node | 4 vCPU | – |
| CPU: שמירה ל-kubelet ולמערכת | 0.08 vCPU | שמירת משאבים ל-kubelet ולמערכת |
| CPU: DaemonSets של המערכת | 0.2 vCPU | DaemonSets של המערכת, CPU |
| CPU: העומסים שלכם בכל node | 0 vCPU | – |
| CPU שאפשר להקצות ל-pods, לכל node | 3.72 vCPU | שמירת משאבים ל-kubelet ולמערכת, DaemonSets של המערכת, CPU |
| זיכרון של node | 16 GiB | – |
| זיכרון: שמירה ל-kubelet ולמערכת | 2.6 GiB | שמירת משאבים ל-kubelet ולמערכת |
| זיכרון: סף פינוי | 0.1 GiB | סף פינוי זיכרון (eviction) |
| זיכרון: DaemonSets של המערכת | 0.39 GiB | DaemonSets של המערכת, זיכרון |
| זיכרון: העומסים שלכם בכל node | 0 GiB | – |
| זיכרון שאפשר להקצות ל-pods, לכל node | 12.91 GiB | שמירת משאבים ל-kubelet ולמערכת, סף פינוי זיכרון (eviction), DaemonSets של המערכת, זיכרון |
| מקומות ל-pods בכל node | 110 | מקסימום pods ל-node |
| CPU שה-pods מבקשים | 7.5 vCPU | – |
| זיכרון שה-pods מבקשים | 11.5 GiB | – |
| nodes שה-pods צריכים (first-fit decreasing) | 3 | שמירת משאבים ל-kubelet ולמערכת, סף פינוי זיכרון (eviction), DaemonSets של המערכת, CPU, DaemonSets של המערכת, זיכרון, מקסימום pods ל-node |
| nodes רזרביים ל-HA | 1 | nodes רזרביים ל-HA (N+k) |
## הנחות
- שמירת משאבים ל-kubelet ולמערכת: 100%. המדרגות ש-GKE מפרסם ל-node pools שנוצרו בגרסה 1.36 ומטה: CPU 6% מהליבה הראשונה, 1% מהשנייה, 0.5% משתי הבאות ו-0.25% מעל ארבע; זיכרון 255 MiB מתחת ל-1 GiB, אחרת 25% מ-4 ה-GiB הראשונים, 20% מ-4 הבאים, 10% מ-8 הבאים, 6% עד 128 GiB ו-2% מעל. 100% מחיל אותן כפי שפורסמו; פלטפורמות אחרות שומרות אחרת, ו-0% לא שומר כלום (ברירת המחדל של Kubernetes עצמו). מקור: https://docs.cloud.google.com/kubernetes-engine/docs/concepts/plan-node-sizes (נקרא ב-16 באוק׳ 2026)
- סף פינוי זיכרון (eviction): 100 MiB. סף הפינוי הקשיח של ה-kubelet כברירת מחדל ב-Linux, memory.available<100Mi: ה-pods מפונים לפני שהזיכרון הפנוי של ה-node יורד מתחתיו, ולכן הוא לא allocatable. מקור: https://kubernetes.io/docs/concepts/scheduling-eviction/node-pressure-eviction/ (נקרא ב-16 באוק׳ 2026)
- DaemonSets של המערכת, CPU: 200 millicores. מה שהסוכנים של הקלסטר עצמו מבקשים בכל node: ה-network plugin (CNI), kube-proxy, סוכן לוגים וסוכן מדדים. משתנה לפי פלטפורמה ותוספים: אפשר לקרוא אותו ב-kubectl describe node. **הנחה**
- DaemonSets של המערכת, זיכרון: 400 MiB. הזיכרון שאותם סוכנים מבקשים בכל node. **הנחה**
- מקסימום pods ל-node: 110. Kubernetes מתוכנן לעד 110 pods ל-node, ברירת המחדל של maxPods ב-kubelet. חלק מהפלטפורמות המנוהלות קובעות מספר אחר. מקור: https://kubernetes.io/docs/setup/best-practices/cluster-large/ (נקרא ב-16 באוק׳ 2026)
- nodes רזרביים ל-HA (N+k): 1. node אחד יותר ממה שה-pods צריכים (N+1): כש-node נופל או מתרוקן לשדרוג, יש לאן להעביר את ה-pods שלו. 0 מתכנן בלי נפילה. **הנחה**
מחשבון kubernetes-resource-planner 1.0.0 · מנוע @anaroq/calc 1.4.0 · תמונת נתונים 2026.10.4
פתיחת החישוב הזה: https://anaroq.com/he/tools/kubernetes-resource-planner#k=eyJhc3N1bXB0aW9ucyI6e30sImNhbGMiOiJrdWJlcm5ldGVzLXJlc291cmNlLXBsYW5uZXIiLCJpbnB1dCI6eyJub2RlQ3B1Ijo0LCJub2RlTWVtb3J5R2liIjoxNiwid29ya2xvYWRzIjpbeyJjcHVMaW1pdE0iOjEwMDAsImNwdVJlcXVlc3RNIjo1MDAsIm1lbW9yeUxpbWl0TWkiOjEwMjQsIm1lbW9yeVJlcXVlc3RNaSI6NTEyLCJuYW1lIjoid2ViIiwicGVyTm9kZSI6ZmFsc2UsInJlcGxpY2FzIjozfSx7ImNwdUxpbWl0TSI6MjAwMCwiY3B1UmVxdWVzdE0iOjEwMDAsIm1lbW9yeUxpbWl0TWkiOjIwNDgsIm1lbW9yeVJlcXVlc3RNaSI6MjA0OCwibmFtZSI6ImFwaSIsInBlck5vZGUiOmZhbHNlLCJyZXBsaWNhcyI6Mn0seyJjcHVMaW1pdE0iOjEwMDAsImNwdVJlcXVlc3RNIjowLCJtZW1vcnlMaW1pdE1pIjowLCJtZW1vcnlSZXF1ZXN0TWkiOjEwMjQsIm5hbWUiOiJ3b3JrZXIiLCJwZXJOb2RlIjpmYWxzZSwicmVwbGljYXMiOjJ9LHsiY3B1TGltaXRNIjowLCJjcHVSZXF1ZXN0TSI6MjAwMCwibWVtb3J5TGltaXRNaSI6NDA5NiwibWVtb3J5UmVxdWVzdE1pIjo0MDk2LCJuYW1lIjoicG9zdGdyZXMiLCJwZXJOb2RlIjpmYWxzZSwicmVwbGljYXMiOjF9XX0sInYiOjF9
איך המחשבונים עובדים: https://anaroq.com/he/methodology#calculators
הקישור מחזיק את ההגדרות אחרי ה-#, ודפדפנים לא שולחים את החלק הזה לשרת.
מה הכלי עושה
הכלי מתכנן את ה-nodes של node pool אחד ב-Kubernetes עבור קבוצת עומסים: כמה nodes בגודל שבחרתם ה-pods צריכים, כמה ה-nodes מלאים, ואיזה pod הולך לאן. הוא סופר את מה שה-scheduler סופר (requests, לא limits) ואת מה שכל node שומר לעצמו, ומוסיף nodes רזרביים לנפילות.
איך זה עובד
- Allocatable לכל node = ה-CPU והזיכרון של ה-node − השמירה ל-kubelet ולמערכת (המדרגות ש-GKE מפרסם) − סף פינוי הזיכרון (100 MiB, ברירת המחדל של ה-kubelet) − ה-DaemonSets של המערכת − העומסים שלכם שסומנו לרוץ בכל node.
- כל pod נספר לפי ה-request שלו; pod עם limit ובלי request נספר לפי ה-limit, כמו ש-Kubernetes עושה. pod בלי שניהם נספר כ-0, אבל עדיין תופס אחד ממקומות ה-pods (110 ל-node כברירת מחדל).
- Bin-packing בשיטת first-fit decreasing: ה-pods ממוינים לפי החלק הגדול ביותר של node שהם תופסים (CPU או זיכרון), וכל אחד נכנס ל-node הראשון שיש בו מקום, או ל-node חדש. אותו קלט נותן תמיד אותו תכנון.
- Nodes = ה-nodes שה-pods צריכים (לפחות אחד) + ה-nodes הרזרביים ל-HA (אחד כברירת מחדל, N+1). הניצולת היא מה שה-pods שמוקמו מבקשים מתוך ה-allocatable של ה-nodes שבשימוש.
- כל תקורה מופיעה תחת הנחות: השמירה, סף הפינוי ומקומות ה-pods עם המקור שפורסם, וה-DaemonSets של המערכת וה-nodes הרזרביים עם הסימון "הנחה".
דוגמה
ארבעה עומסים על nodes של 4 vCPU ו-16 GiB, כשכל ההנחות בברירת המחדל:
web 3 × 500m/512Mi · api 2 × 1000m/2Gi · worker 2 × limit 1000m/1Gi · postgres 1 × 2000m/4Gi
- Nodes
- 4
- CPU מבוקש מתוך ה-allocatable
- 67.2%
- זיכרון מבוקש מתוך ה-allocatable
- 29.7%
- CPU שאפשר להקצות לכל node
- 3.72 vCPU
- זיכרון שאפשר להקצות לכל node
- 12.91 GiB
- Pods שמוקמו
- 8
- Pods שלא נכנסים לאף node
- 0
מגבלות
- תכנון לפי requests, לא מדידה: אם ה-requests רחוקים ממה שה-pods צורכים, גם התכנון רחוק. קבעו אותם לפי שימוש אמיתי (kubectl top, המדדים שלכם).
- Node pool אחד וגודל node אחד. Taints, affinity, topology spread, אזורים ואחסון אינם במודל; הם עלולים לדרוש יותר nodes מאריזה בלבד.
- בלי autoscaling: מספר ה-replicas שהזנתם קבוע. תכננו לפי מספר ה-replicas בשיא של HorizontalPodAutoscaler.
- השמירה שונה בין פלטפורמות: EKS, AKS, k3s ו-kubeadm שומרים אחרת ממדרגות GKE. קראו את ה-allocatable של node אמיתי (kubectl describe node) והתאימו את השמירה.
- בלי מחיר: התכנון נותן את ה-nodes; העלות של קלסטר מנוהל לא מחושבת כאן.
מתודולוגיה: איך מחושבים המספרים
מקורות
קשורים
הצעד הבא
כלי ציבורי חינמי של אנרוק, חברה שבונה תשתיות מחשוב. מה אנרוק בונה