מתכנן משאבים ל-Kubernetes

הזינו את גודל ה-node ואת העומסים (replicas, ‏requests ו-limits של CPU וזיכרון), או הדביקו את ה-manifests שלהם. תקבלו את מספר ה-nodes, כמה הם מלאים, מה ממוקם בכל אחד ואילו pods לא נכנסים, כשכל תקורה מוצגת עם המקור שלה.

גודל ה-node
סוג המכונה של ה-node pool, למשל 4 vCPU.
הזיכרון שלה ב-GiB, למשל 16.

עומסים

לכל pod. ‏1000 millicores = ‏1 vCPU; ‏0 פירושו לא הוגדר.

עומס 1: web
עומס 2: api
עומס 3: worker
עומס 4: postgres

עד 50 עומסים.

ייבוא מ-manifests

הדביקו YAML של Kubernetes: ‏Deployments, ‏StatefulSets, ‏DaemonSets, ‏ReplicaSets, ‏Jobs ו-Pods, כמה מסמכים מופרדים בשורת ---. רק ה-kind, השם, ה-replicas וה-requests וה-limits של CPU וזיכרון של ה-containers נקראים.

השורות שאתם מייבאים הופכות לקלט רגיל: השמות והמספרים שלהן נכנסים לקישור השיתוף כמו כל דבר שאתם מקלידים. ה-YAML עצמו לא נשמר.

נשאר רק בדפדפן שלך. מה שהדבקתם או בחרתם נקרא רק בעמוד הזה. הוא לא נשלח לשרת, לא נשמר בקישור או באחסון הדפדפן, ולעולם לא נכלל ב-analytics.

הדביקו את הטקסט, או בחרו קובץ מהמחשב. עד 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 של node4 vCPU
    CPU: שמירה ל-kubelet ולמערכת0.08 vCPU
    • שמירת משאבים ל-kubelet ולמערכת
    CPU: ‏DaemonSets של המערכת0.2 vCPU
    • DaemonSets של המערכת, CPU (הנחה)
    CPU: העומסים שלכם בכל node0 vCPU
      CPU שאפשר להקצות ל-pods, לכל node3.72 vCPU
      • שמירת משאבים ל-kubelet ולמערכת
      • DaemonSets של המערכת, CPU (הנחה)
      זיכרון של node16 GiB
        זיכרון: שמירה ל-kubelet ולמערכת2.6 GiB
        • שמירת משאבים ל-kubelet ולמערכת
        זיכרון: סף פינוי0.1 GiB
        • סף פינוי זיכרון (eviction)
        זיכרון: ‏DaemonSets של המערכת0.39 GiB
        • DaemonSets של המערכת, זיכרון (הנחה)
        זיכרון: העומסים שלכם בכל node0 GiB
          זיכרון שאפשר להקצות ל-pods, לכל node12.91 GiB
          • שמירת משאבים ל-kubelet ולמערכת
          • סף פינוי זיכרון (eviction)
          • DaemonSets של המערכת, זיכרון (הנחה)
          מקומות ל-pods בכל node110
          • מקסימום 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 רזרביים ל-HA1
              • nodes רזרביים ל-HA ‏(N+k) (הנחה)

              מחשבון kubernetes-resource-planner 1.0.0 · מנוע @anaroq/calc 1.4.0 · תמונת נתונים 2026.10.4 · איך המחשבונים עובדים

              הנחות

              כל מספר שהתוצאה משתמשת בו ולא הזנתם. אפשר לשנות כל אחד מהם כך שיתאים למקרה שלכם.

              • %

                המדרגות ש-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 והזיכרון שאפשר להקצות בו הם מבקשים.

              1. Node 1CPU 3.5 vCPU מתוך 3.72 vCPU · זיכרון 6.5 GiB מתוך 12.91 GiB · ‏3 podsweb × 1, api × 1, postgres × 1
              2. Node 2CPU 3.5 vCPU מתוך 3.72 vCPU · זיכרון 4.5 GiB מתוך 12.91 GiB · ‏4 podsweb × 1, api × 1, worker × 2
              3. Node 3CPU 0.5 vCPU מתוך 3.72 vCPU · זיכרון 0.5 GiB מתוך 12.91 GiB · ‏1 podsweb × 1
              4. Node רזרבי 1 ‏(HA)ריק: מקום ל-pods של node שנופל או מתרוקן.

              לקחת את התכנון איתכם

              התכנון כקובץ Markdown: גודל ה-node, העומסים, התוצאה, האזהרות, כל node, כל הנחה עם המקור או הסימון שלה, והקישור שמשחזר אותו.

              kubernetes-resource-plan.md
              # מתכנן משאבים ל-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 רזרביים לנפילות.

              איך זה עובד

              1. Allocatable לכל node = ה-CPU והזיכרון של ה-node − השמירה ל-kubelet ולמערכת (המדרגות ש-GKE מפרסם) − סף פינוי הזיכרון (100 MiB, ברירת המחדל של ה-kubelet) − ה-DaemonSets של המערכת − העומסים שלכם שסומנו לרוץ בכל node.
              2. כל pod נספר לפי ה-request שלו; pod עם limit ובלי request נספר לפי ה-limit, כמו ש-Kubernetes עושה. ‏pod בלי שניהם נספר כ-0, אבל עדיין תופס אחד ממקומות ה-pods ‏(110 ל-node כברירת מחדל).
              3. Bin-packing בשיטת first-fit decreasing: ה-pods ממוינים לפי החלק הגדול ביותר של node שהם תופסים (CPU או זיכרון), וכל אחד נכנס ל-node הראשון שיש בו מקום, או ל-node חדש. אותו קלט נותן תמיד אותו תכנון.
              4. Nodes = ה-nodes שה-pods צריכים (לפחות אחד) + ה-nodes הרזרביים ל-HA (אחד כברירת מחדל, N+1). הניצולת היא מה שה-pods שמוקמו מבקשים מתוך ה-allocatable של ה-nodes שבשימוש.
              5. כל תקורה מופיעה תחת הנחות: השמירה, סף הפינוי ומקומות ה-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; העלות של קלסטר מנוהל לא מחושבת כאן.

              מתודולוגיה: איך מחושבים המספרים

              מקורות

              1. ANAROQ calculator methodology: assumptions, units and rounding
              2. Kubernetes Documentation: Resource Management for Pods and Containers
              3. Kubernetes Documentation: Node-pressure Eviction
              4. Kubernetes Documentation: Considerations for large clusters
              5. Google Kubernetes Engine: Plan node sizes

              עודכן

              הצעד הבא

              ממיר Docker Compose ל-Kubernetes

              כלי ציבורי חינמי של אנרוק, חברה שבונה תשתיות מחשוב. מה אנרוק בונה