📘 תיעוד 98

שליטה בגישה לשרתי MCP בארגון

הגבילו אילו שרתי MCP משתמשים יכולים להוסיף או להתחבר אליהם, או ספקו שרתים לכל משתמש, באמצעות קבצי תצורה מנוהלים, הגדרות מנוהלות, רשימות היתר ורשימות חסימה.

כברירת מחדל, כל מי שמריץ את Claude Code יכול להתחבר לכל שרת MCP שיבחר. Anthropic בודקת מחברים מול קריטריוני הרישום שלה לפני הוספתם לספריית Anthropic, אבל לא מבצעת ביקורת אבטחה ולא מנהלת שום שרת MCP. כמנהל, אפשר להגביל אילו שרתים רצים בארגון, מפריסה של סט מאושר קבוע ועד השבתת MCP לגמרי, ואפשר לספק שרתים לכל משתמש.

ההגבלות האלה מכסות את השרתים שClaude Code טוען בעצמו, כולל המחברים שהוא מביא מclaude.ai. מחברים שאפליקציית שולחן העבודה מעבירה לסשנים המקומיים ולסשני SSH שלה מגיעים בתוך התהליך ומנוהלים מהגדרות הארגון בclaude.ai. איך מחברים מגיעים לClaude Code מראה אילו בקרות חלות על מחברים בכל סוג סשן, כולל סשנים בענן.

הדף הזה מסביר איך:

• לבחור דפוס שמתאים למידת השליטה שצריך
• לפרוס סט שרתים קבוע עם managed-mcp.json, כולל איך להשבית את MCP לגמרי
• לספק שרתים דרך הגדרות מנוהלות בזמן שמשתמשים שומרים על השרתים שלהם
• לשלוט בשרתים עם רשימות היתר ורשימות חסימה
• לומר למשתמשים למה לצפות כשהגבלה חוסמת שרת
• לנטר אילו שרתים הארגון באמת משתמש בהם

[!NOTE]

דף האבטחה מכסה את מודל האיומים של MCP ואיך להעריך שרת לפני אישורו. החליטו מה לאכוף מכסה הגבלות MCP לצד שאר הבקרות הניהוליות.

#בחירת דפוס

Claude Code תומך בטווח של רמות הגבלה. כל דפוס משתמש באחד או יותר מהמנגנונים שמכוסים בהמשך: managed-mcp.json לפריסת סט קבוע, ההגדרה המנוהלת managedMcpServers לאספקת שרתים לצד אלה שמשתמשים מוסיפים, וallowedMcpServers/deniedMcpServers לסינון מה שמשתמשים מגדירים.

[!NOTE]

לClaude Code אין רישום שרתי MCP מובנה שמשתמשים יכולים לעיין בו ולהתקין ממנו. לדפוס הקטלוג המאושר, שתפו את הרשימה המאושרת ואת פקודות claude mcp add שלה במקום שהמשתמשים ימצאו, למשל ויקי פנימי, או הפיצו את השרתים כתוספים דרך שוק תוספים מנוהל כדי שמשתמשים יוכלו לעיין בהם ולהתקין אותם מ/plugin.

#שליטה בלעדית עם managed-mcp.json

כשפורסים קובץ managed-mcp.json, Claude Code טוען רק את שרתי הMCP האלה:

• השרתים שהקובץ מגדיר
• שרתים שמספקים דרך managedMcpServers
• שרתים בתוך התהליך שהאפליקציה שהתחילה את הסשן רושמת, למשל השרת של תוסף VS Code או המחברים שאפליקציית שולחן העבודה מעבירה
• שרת Claude in Chrome המובנה, אם מתירים אותו לצד הסט המנוהל

משתמשים לא יכולים להוסיף, לשנות או להשתמש בשום שרתי MCP אחרים, כולל שרתים שמגיעים מתוספים ושרתים שמועברים עם דגל הCLI --mcp-config. הקובץ גם מדכא את מחברי claude.ai שClaude Code מביא בעצמו, אלא אם מתירים אותם לצד הסט המנוהל.

#פריסת managed-mcp.json

managed-mcp.json הוא קובץ עצמאי, ולכן אי אפשר למסור אותו דרך הגדרות שמנוהלות בשרת. כדי למסור שרתים דרך הגדרות מנוהלות במקום זאת, בלי שליטה בלעדית, השתמשו בmanagedMcpServers.

כל תהליך שיכול לכתוב לנתיב מערכת עם הרשאות מנהל יכול לפרוס את הקובץ. בצי מכשירים, זה בדרך כלל דרך כלי ניהול מכשירים, כמו Jamf או פרופיל תצורה בmacOS, Group Policy או Intune בWindows, או ניהול הצי שבחרתם בLinux. Claude Code מחפש את הקובץ באחד מהנתיבים האלה:

הקובץ משתמש באותו פורמט כמו קובץ .mcp.json של פרויקט:

{
  "mcpServers": {
    "github": {
      "type": "http",
      "url": "https://api.githubcopilot.com/mcp/"
    },
    "sentry": {
      "type": "http",
      "url": "https://mcp.sentry.dev/mcp"
    },
    "company-internal": {
      "type": "stdio",
      "command": "/usr/local/bin/company-mcp-server",
      "args": ["--config", "/etc/company/mcp-config.json"],
      "env": {
        "COMPANY_API_URL": "https://internal.example.com"
      }
    }
  }
}

#אימות עם אישורים לכל משתמש

כל משתמש במכונה יכול לקרוא את הקובץ הזה, אז אל תשמרו מפתחות API או אישורים אחרים בבלוקי env. העבירו אישורים לכל משתמש באחת מהדרכים האלה במקום זאת:

• התרחבות ${VAR} כדי לקרוא סודות מסביבת כל משתמש.
• OAuth או כותרות לכל משתמש כדי שכל משתמש יאמת את עצמו.
• headersHelper כדי ליצור אישורים בזמן החיבור.

#שרתים שמועברים עם --mcp-config או --strict-mcp-config

כשסשן מקבל שרתים דרך --mcp-config בזמן שקובץ managed-mcp.json שClaude Code יכול לקרוא ולנתח פרוס, מה שהמשתמש רואה שונה בין תחנת עבודה לסשן ענן:

• בתחנת עבודה, Claude Code יוצא בהפעלה עם You cannot dynamically configure MCP servers when an enterprise MCP config is present.
• בסשנים בענן על מארח שבו הקובץ פרוס, למשל רץ באירוח עצמי, Claude Code מתחיל עם השרתים המנוהלים בלבד ומדלג על מחברי claude.ai ועל שרתים אחרים שמארח הענן מעביר דרך --mcp-config. שום דבר בסשן לא אומר למשתמש אילו שרתים הושמטו. Claude Code מציין אותם באזהרה בstderr שלו, שרץ באירוח עצמי רושם ברמת לוג debug.

דגל --strict-mcp-config מבקש להחליף את הסט המנוהל. אם משתמש מעביר אותו בזמן שקובץ כזה פרוס, Claude Code יוצא בהפעלה גם בתחנת עבודה וגם בסשן ענן.

#איך רשימות היתר ורשימות חסימה חלות על הסט המנוהל

רשימת החסימה יכולה לסנן עוד את השרתים בmanaged-mcp.json:

• deniedMcpServers חל גם על שרתים מנוהלים, כך ששרת מנוהל שתואם לרשומה לא ייטען.
• deniedMcpServers של המשתמש עצמו מתמזג מההגדרות שלו, כך שמשתמשים יכולים לחסום שרת מנוהל עבור עצמם.

השרתים בmanaged-mcp.json לא צריכים רשומת allowedMcpServers, עם חריג אחד: Claude Code בודק שרת מול רשימת ההיתר כשהוא משתמש בהתרחבות ${VAR} מחוץ לenv. לפני v2.1.305, הוא גם בדק שרת שהשתמש בהתרחבות ${VAR} רק בenv, ולפני v2.1.259, כל שרת מנוהל בכל פעם שהוגדרה רשימת היתר. ראו איך שרת מוערך לגבי אילו שדות מפעילים את בדיקת ${VAR} ולסדר המלא של הבדיקות.

אם השתמשתם בallowedMcpServers כדי למנוע טעינה של חלק מהשרתים בmanaged-mcp.json, הוסיפו עבורם רשומות deniedMcpServers, או פרסו managed-mcp.json נפרד לכל קבוצה, לפני שהמשתמשים משדרגים. אלא אם הם משתמשים בהתרחבות ${VAR} מחוץ לenv, השרתים האלה מתחילים להיטען בהפעלה הראשונה של כל משתמש בגרסה שלא בודקת אותם, בלי בקשה ובלי הודעה.

#אימות התצורה

כדי לאשר שהקובץ בתוקף, הריצו שתי בדיקות במכונה מנוהלת:

1. claude mcp list מציג רק את השרתים בmanaged-mcp.json, ועוד כל שרת שמספקים דרך managedMcpServers. שתי תוצאות אחרות אומרות שמשהו לא תקין:
   • אם שרתים של המשתמש עצמו עדיין מופיעים, Claude Code לא קורא את הקובץ, אז בדקו את הנתיב שלו ואת ההרשאות על ספריות האב שלו.
   • אם שרתי הקובץ לא מופיעים ומקטע MCP config diagnostics מסמן את תצורת הארגון ככזו שנכשלה בניתוח, Claude Code לא יכול לקרוא או לנתח את הקובץ. תקנו את השגיאה שהמקטע מציין, ואז בקשו מהמשתמש להפעיל מחדש את Claude Code.
2. claude mcp add --transport http test https://example.com/mcp נכשל עם Cannot add MCP server: enterprise MCP configuration is active and has exclusive control over MCP servers. כתובת הURL לא צריכה להיות שרת אמיתי, כי בדיקת המדיניות דוחה את הפקודה לפני שנוצר קשר עם משהו.

#השבתת MCP לגמרי

פרסו managed-mcp.json שמכיל מפת שרתים ריקה כדי לחסום כל שרת MCP חוץ מאלה שנטענים תחת שליטה בלעדית:

{
  "mcpServers": {}
}

claude mcp add נכשל עם שגיאת מדיניות הארגון שלמעלה. שרתים שמשתמשים הגדירו בעבר מפסיקים להיטען בפעם הבאה שהם מתחילים סשן, בלי אזהרה שהמדיניות היא הסיבה. שרתים שמספקים דרך managedMcpServers, וכל דבר אחר שמתירים לצד הסט המנוהל, עדיין נטענים תחת מפה ריקה, אז השאירו את המפתחות האלה לא מוגדרים כדי לכבות את MCP לגמרי.

#התרת מחברי claude.ai לצד הסט המנוהל

כברירת מחדל, פריסת managed-mcp.json מדכאת את מחברי claude.ai שClaude Code מביא בעצמו, כולל מחברים שמנהל הגדיר לארגון במסוף הניהול של claude.ai. כדי לטעון את המחברים האלה לצד השרתים בmanaged-mcp.json, הגדירו "allowAllClaudeAiMcps": true במקור הגדרות מנוהלות.

כשההגדרה מופעלת, Claude Code טוען את אותם מחברי claude.ai שהיה טוען אם managed-mcp.json לא היה פרוס. רשימות היתר ורשימות חסימה עדיין חלות על המחברים האלה, כך שאפשר לחסום מחברים מסוימים עם deniedMcpServers. ההגדרה משפיעה רק על מחברי claude.ai שClaude Code מביא בעצמו. שרתים שמגיעים מתוספים נשארים מדוכאים.

סשנים בענן והסשנים המקומיים וסשני SSH של אפליקציית שולחן העבודה מקבלים מחברים בדרך אחרת, שמתוארת באיך מחברים מגיעים לClaude Code. managed-mcp.json על המארח שמריץ סשן ענן, למשל מארח רץ באירוח עצמי, מדכא את המחברים של הסשן הזה בין אם מגדירים allowAllClaudeAiMcps ובין אם לא. שום managed-mcp.json לא מגיע למחברים שאפליקציית שולחן העבודה מעבירה לסשנים המקומיים ולסשני SSH שלה.

Claude Code קורא את allowAllClaudeAiMcps רק משכבות מדיניות שבשליטת מנהל: הגדרות שמנוהלות בשרת, plist שנפרס בMDM או מפתח רישום HKLM, או קובץ מערכת managed-settings.json. הצבתו בהגדרות משתמש או פרויקט לא משפיעה, כך שמשתמשים לא יכולים להפעיל מחדש מחברים ששליטה בלעדית דיכאה.

#התרת Claude in Chrome לצד הסט המנוהל

כברירת מחדל, כשפורסים managed-mcp.json, Claude Code חוסם את שרת Claude in Chrome המובנה בסשני טרמינל. משתמשים לא מקבלים את הנחיית התקנת התוסף, וסשן שבו המשתמש הפעיל את Chrome כברירת מחדל מתחיל בלעדיו ולא מדפיס אזהרה. אם משתמש שיכול היה אחרת להריץ את Claude in Chrome מפעיל claude --chrome, Claude Code יוצא בהפעלה עם שגיאה שמציינת את ההגדרה allowClaudeInChromeWithManagedMcp.

כדי לאפשר למשתמשים להריץ את Claude in Chrome לצד הסט המנוהל, הגדירו "allowClaudeInChromeWithManagedMcp": true בהגדרות המנוהלות של המכשיר עצמו. שימו אותו בplist שנפרס בMDM, במפתח רישום HKLM, או בקובץ מערכת managed-settings.json, לפי מה שClaude Code בוחר באותו מכשיר. נדרש Claude Code v2.1.282 או חדש יותר. Claude Code קורא את ההגדרה רק מהמקורות האלה במכשיר, גם כשהגדרות שמנוהלות בשרת מוסרות את שאר המדיניות. רשומת deniedMcpServers עבור claude-in-chrome עדיין חוסמת את השרת כשההגדרה מופעלת.

#אספקת שרתים דרך הגדרות מנוהלות

כדי לתת לכל משתמש קבוצה של שרתי MCP מרוחקים בלי לקחת שליטה בלעדית על MCP, יש לרשום אותם תחת managedMcpServers במקור הגדרות מנוהלות: הגדרות שמנוהלות בשרת, מדיניות של Claude apps gateway, פרופיל MDM או מדיניות registry, או managed-settings.json. המשתמשים שומרים על השרתים שהם מוסיפים בעצמם ומקבלים את השרתים שלך בנוסף. נדרש Claude Code בגרסה v2.1.259 או חדשה יותר. לקוחות מוקדמים יותר מתעלמים מהמפתח.

הערך הוא אובייקט שהמפתחות שלו הם שמות שרתים. לכל רשומה יש אותה צורה כמו לשרת HTTP או SSE בקובץ .mcp.json של פרויקט, כולל האיברים האופציונליים headers ו-oauth שמתוארים באימות מול שרתי MCP מרוחקים. הדוגמה הזו מספקת שרת חיפוש שכל משתמש מתחבר אליו עם OAuth, ושרת רשומות ששולח כותרת שהארגון שלך מנפיק:

{
  "managedMcpServers": {
    "search": {
      "type": "http",
      "url": "https://search.example.com/mcp"
    },
    "records": {
      "type": "http",
      "url": "https://records.example.com/mcp",
      "headers": {
        "X-Records-Key": "key-issued-for-all-claude-code-users"
      }
    }
  }
}

כל מי שיכול לקרוא את ההגדרות המנוהלות במכונה, כולל המשתמש, יכול לקרוא ערך כותרת שהגדרת כאן. השתמש באישור שהונפק לכל הקהל הזה, או השמט את headers ותן לכל משתמש להתחבר עם OAuth.

#מה רשומה יכולה להכיל

Claude Code טוען רשומה רק כשהיא עוברת כל בדיקה שמופיעה למטה. הוא משמיט רשומה שנכשלת באחת מהן, רושם הודעה שאפשר לקרוא עם /status, ועדיין טוען את שאר הרשומות:

• type הוא http או sse. כמו ב-.mcp.json, streamable-http מתקבל ככינוי ל-http.
• url הוא כתובת https://. Claude Code מסרב לכתובת http:// רגילה, כולל כתובת שמצביעה על localhost.
• לרשומה אין איבר command, args, env או headersHelper, כך שמסמך הגדרות מנוהלות אף פעם לא מציין תוכנית להרצה במכונה של המשתמש.
• אף ערך לא מכיל הפניה ${VAR}. Claude Code לא מרחיב משתני סביבה ברשומות האלה, לכן כתוב ערכים מילוליים.
• שם השרת מכיל רק אותיות, מספרים, מקפים וקווים תחתונים, ואף מפתח או ערך לא מכיל תווי בקרה או תווי עיצוב בלתי נראים.

ל-Claude Desktop יש הגדרה מנוהלת באותו שם שהערך שלה הוא מערך עם צורת רשומה שונה, לכן אל תעתיק מאחת לשנייה. Claude Code לא מקבל את צורת המערך ורושם הודעה במקום לטעון אותה.

Claude apps gateway מריץ את אותן בדיקות כשהוא עולה. ראה שרתי MCP במדיניות.

#איך שרתים שסופקו נטענים

הכללים האלה קובעים מה נטען כששרת שסופק חופף להגדרת שרת אחרת או להגדרה אחרת בדף הזה:

• שרת שסופק מקבל קדימות על פני שרת באותו שם בהיקף local, project או user, ועל פני שרת של תוסף או מחבר claude.ai שמצביע על אותה כתובת URL.
• אם פורס גם managed-mcp.json, Claude Code טוען את השרתים שלו ואת השרתים שסופקו יחד, והרשומה מהקובץ מקבלת קדימות כששניהם מגדירים שם.
• שרתים שסופקו ממשיכים להיטען כש-strictPluginOnlyCustomization נועל את משטח mcp.
• deniedMcpServers חל על שרתים שסופקו, כולל רשומות מההגדרות של המשתמש עצמו, כך שמשתמש יכול לחסום אחד עבור עצמו. שרתים שסופקו לא צריכים רשומת allowedMcpServers.

כשלא פורס גם managed-mcp.json, הדגלים לכל הרצה שומרים על המשמעות שלהם:

• שרת שמשתמש מעביר עם --mcp-config תחת אותו שם מחליף את השרת שסופק לאותה הרצה ונבדק מול allowedMcpServers.
• --strict-mcp-config משמיט את השרתים שסופקו יחד עם כל שרת מוגדר אחר.

כש-managed-mcp.json פרוס, שני הדגלים מתנהגים כמו שמתואר בשליטה בלעדית עם managed-mcp.json.

#מה משתמשים יכולים לראות ולשנות

משתמשים לא יכולים לערוך או להסיר שרת שסופק:

• claude mcp remove מדווח שהשרת סופק על ידי הארגון.
• כשלא פורס גם managed-mcp.json, רשומה שמשתמש מוסיף תחת אותו שם נשמרת אבל לא בשימוש כל עוד הרשומה שלך קיימת.
• משתמשים עדיין יכולים לכבות שרת שסופק עבור עצמם ב-/mcp, שמציג שרתים שסופקו תחת Managed MCPs.

claude mcp get ו-/mcp מציגים את כתובת ה-URL של שרת שסופק כמארח בלבד, לדוגמה https://mcp.example.com/…, ו-claude mcp get מציג את שמות הכותרות בלי הערכים שלהן.

#איפה managedMcpServers חל

Claude Code קורא את managedMcpServers מהמקור המנוהל שהוא בוחר תחת איך Claude Code משלב מקורות מנוהלים. כשהמקור הזה מגדיר את managedSourcesBehavior ל-"merge", Claude Code מספק את השרתים מכל מקור מנהל במקום זאת, וכששני מקורות מגדירים את אותו שם, הרשומה של המקור בדירוג הגבוה יותר חלה בשלמותה. הוא אף פעם לא קורא את המפתח מ-registry של HKCU שניתן לכתיבה על ידי המשתמש, מהגדרות הורה שמארח מטמיע מספק, או מקובצי הגדרות user, project או local, שבהם הוא משמיט את המפתח עם אזהרה.

Claude Code לא קורא את המפתח בלשונית Code של אפליקציית Claude Desktop בפריסה של צד שלישי או בסשנים של Cowork באפליקציה, כי Claude Desktop מספק ונועל את שרתי ה-MCP של הסשנים האלה בעצמו. /status ו-claude doctor אומרים זאת כשההגדרות המנוהלות שלך נושאות את המפתח שם.

#מתי שרתים שסופקו מתחברים

כש-managedMcpServers מגיע דרך הגדרות שמנוהלות בשרת, התזמון שלו עוקב אחרי התנהגות שליפה ומטמון:

• במכונה עם הגדרות במטמון, Claude Code מונע את העותק שבמטמון של המפתח הזה עד שהשרת מאשר את ההגדרות לסשן, ומחכה לאישור הזה לפני שהוא טוען שרתי MCP. אם האישור נכשל, הסשן ממשיך בלי השרתים שסופקו ו-/status אומר שהם מונעים.
• בהפעלה הראשונה של מכונה, כשעדיין אין כלום במטמון, סשן אינטראקטיבי שמתחיל לפני שההגדרות מגיעות מחבר את השרתים שסופקו ברגע שהן מגיעות, והרצה של claude -p שכבר התחילה יכולה להסתיים בלעדיהם.

עם כניסה דרך gateway, Claude Code טוען את המדיניות לפני שהסשן מתחיל, כך שאף אחד משני המקרים לא מעכב או מדלג על השרתים שסופקו.

סשנים אינטראקטיביים שכבר רצים מיישמים את העריכות שלך במפתח:

• הוספת שרת: Claude Code מתחבר אליו כשההגדרות המעודכנות מגיעות, בלי הפעלה מחדש.
• שינוי רשומה של שרת: הסשנים האלה מתחברים אליו מחדש עם ההגדרה החדשה.
• הסרת שרת: סשן אינטראקטיבי שרץ מנתק אותו ברגע שהוא קורא את ההגדרות שהשתנו. הרצה לא אינטראקטיבית (-p) שומרת אותו עד שהיא מסתיימת.

#בקרה מבוססת מדיניות עם רשימות היתר ורשימות חסימה

רשימות היתר ורשימות חסימה מסננות אילו שרתים מוגדרים מורשים להיטען. הן אינן מרשם: שרת עדיין צריך להתווסף על ידי משתמש, תוסף, או הארגון שלכם לפני שאחת מהרשימות חלה עליו.

שרתים שהארגון שלכם מספק דרך managedMcpServers נטענים בלי רשומה ברשימת ההיתר, ושרתים שמדלגים על בדיקת רשימת ההיתר מכסה את שרתי managed-mcp.json. רשימת החסימה חלה על כל שרת בלי קשר למקום שממנו הגיע, למעט רשומות type: "sdk" בתוך התהליך.

כדי לפרוס שרתים למשתמשים, השתמשו ב-managed-mcp.json או ב-managedMcpServers. שתי הרשימות גם מסננות שרתים שמשתמש מעביר עם דגל ה-CLI --mcp-config, למעט רשומות type: "sdk" בתוך התהליך. --strict-mcp-config מגביל אילו קובצי תצורה נטענים ואינו עוקף אף אחת מהרשימות.

כדי להפוך את רשימת ההיתר לסמכות הקובעת, הגדירו את allowedMcpServers ואת allowManagedMcpServersOnly: true יחד במקור הגדרות מנוהלות, כגון הגדרות שמנוהלות על ידי השרת או קובץ managed-settings.json שנפרס.

הנעילה חלה מכל מקור מנוהל שבשליטת מנהל, כך שנעילה בקובץ שנפרס עדיין חלה גם כאשר בשימוש הגדרות שמנוהלות על ידי השרת ואינן מזכירות את MCP. כל עוד הנעילה פעילה, רשימת ההיתר המנוהלת מגיעה ממקור המנהל המדורג גבוה ביותר שמגדיר רשימה כזו. קריאה של הנעילה ושל רשימת ההיתר מתוך מקורות שונים דורשת Claude Code v2.1.273 או גרסה מאוחרת יותר.

הגבלת רשימת ההיתר להגדרות מנוהלות בלבד מציגה את התצורה.

בלי allowManagedMcpServersOnly, רשימות היתר מכל היקף הגדרות מתמזגות, כולל ~/.claude/settings.json של המשתמש עצמו, כך שמשתמש יכול להרחיב את מה שרשימת ההיתר שלכם מתירה. רשימות חסימה מתמזגות מכל היקף בכל מקרה.

[!NOTE]

allowManagedMcpServersOnly נפרד מ-allowManagedPermissionRulesOnly, אשר נועל רק כללי הרשאה. הגדרת הדגל הזה אינה אוכפת את רשימת ההיתר של MCP.

#התאמת שרתים לפי URL, פקודה, או שם

allowedMcpServers ו-deniedMcpServers הן רשימות של רשומות. כל רשומה היא אובייקט עם מפתח יחיד שמזהה שרתים לפי כתובת ה-URL שלהם, לפי הפקודה שלהם, או לפי השם שלהם:

השארת allowedMcpServers לא מוגדר שונה מהגדרתו למערך ריק:

ראו רשומות לא תקינות בהגדרות מנוהלות לגבי מה שקורה כאשר רשומה נכשלת באימות הסכמה.

#איך רשומות serverName מותאמות

רשומת serverName מתאימה במדויק לתווית שהמשתמש הקצה, בלי תווי הכללה.

[!WARNING]

רשומת serverName, בכל אחת מהרשימות, אינה בקרת אבטחה. השם הוא התווית שמשתמש מקצה כאשר מריצים claude mcp add או עורכים קובץ תצורה, לא השרת עצמו, כך שמשתמש יכול לקרוא לכל שרת github. עבור מחברי claude.ai השם הוא שם התצוגה ש-claude.ai מחזיר, והוא יכול להשתנות. כדי לאכוף אילו שרתים באמת רצים, הוסיפו רשומות serverCommand או serverUrl.

אימות serverName שונה בין שתי הרשימות:

• ב-deniedMcpServers, serverName מקבל כל מחרוזת לא ריקה בלי רווח לבן בתחילתה או בסופה, כך שאפשר לחסום מחברי claude.ai לפי שם התצוגה שלהם. לדוגמה, { "serverName": "claude.ai Slack" } חוסם את מחבר Slack. העדיפו רשומת serverUrl כאשר החסימה צריכה להיות עמידה בפני שינוי שמות, או כאשר שם מחבר מתנגש ומקבל סיומת (N).
• ב-allowedMcpServers, serverName מוגבל לאותיות, מספרים, מקפים וקווים תחתונים. השתמשו ב-serverUrl כדי להכניס לרשימת ההיתר מחבר claude.ai ש-Claude Code מביא בעצמו. עבור מחברים שמארח ענן מספק להפעלות באירוח עצמי, השתמשו ברשומות שמפורטות תחת תעבורת מחברים יוצאת מהרשת שלכם.

כדי לכבות את כל מחברי claude.ai ש-Claude Code מביא בעצמו, ראו disableClaudeAiConnectors.

#איך רשומות serverCommand מותאמות

רשומת serverCommand מחזיקה את הפקודה ואת הארגומנטים שלה כמערך אחד, כמו ב-{ "serverCommand": ["npx", "-y", "server"] }. Claude Code משווה את המערך הזה לפקודה ולארגומנטים בתצורת השרת:

• הפקודות מותאמות בדיוק. כל ארגומנט, לפי הסדר. ["npx", "-y", "server"] אינו מתאים ל-["npx", "server"] או ל-["npx", "-y", "server", "--flag"].
• בלוק env אינו מושווה. ["node", "server.js"] מתאים לשרת שמריץ את הפקודה הזו עם כל ערכי env. חלק ממשתני הסביבה משנים את מה ש-node טוען בעת ההפעלה. כדי להגדיר את ערכי env בעצמכם, הגדירו את השרת ב-managed-mcp.json.

#איך רשומות serverUrl מותאמות

כתובות URL תומכות בתווי הכללה *, כולל * בתור הסכמה כולה. התאמת שם המארח אינה תלויה ברישיות ומתעלמת מנקודת FQDN סופית, כך ש-https://Mcp.Example.com/* מתאים ל-https://mcp.example.com/api. נתיבים נשארים תלויי רישיות. אם לא מציינים פורט, אופן כתיבת שם המארח קובע אם התבנית מתאימה רק לפורט ברירת המחדל של הסכמה או לכל פורט:

• שם מארח שנכתב במלואו: פורט ברירת המחדל בלבד, 443 עבור https ו-80 עבור http
• שם מארח עם * בתוכו: כל פורט

הטבלה מראה מה תבניות נפוצות מתירות:

רשומות ב-deniedMcpServers מתאימות פורטים באותו אופן, אז בחרו רשומה עבור staging.example.com לפי הפורטים והסכמות שאתם צריכים לחסום:

• https://staging.example.com/*: חוסם שרתי https במארח הזה בפורט 443 בלבד, כך שהוא אינו חוסם שרת בכתובת https://staging.example.com:8443/api
• https://staging.example.com:*/*: חוסם שרתי https במארח הזה בכל פורט
• *://staging.example.com:*/*: חוסם את המארח הזה בכל סכמה ובכל פורט

#משתני סביבה ברשומות serverCommand ו-serverUrl

ערכי serverCommand ו-serverUrl מורחבים לפני ההתאמה. גם רשומת המדיניות וגם הערך המוגדר של השרת עוברים הרחבת ${VAR} ו-${VAR:-default}, כך שרשומה שנכתבת כ-["${HOME}/bin/server"] מתאימה לתצורת שרת שמשתמשת באותה הפניה או בנתיב המורחב. ערכי serverName מותאמים באופן מילולי ולעולם אינם מורחבים.

שני הצדדים קוראים סביבות שונות:

• הערך המוגדר של השרת: מורחב מסביבת התהליך החיה, כמו שאר .mcp.json
• רשומת מדיניות: מורחבת מסביבה מוצמדת, כך שמשתנה שהוגדר בקובץ הגדרות של פרויקט או של משתמש אינו יכול לשנות את המשמעות של רשומת רשימת היתר

מכיוון שרשומת מדיניות עדיין תלויה בערך של המעטפת המפעילה עבור כל משתנה שהיא מפנה אליו, השתמשו בכתובות URL ובפקודות מילוליות עבור רשומות שאתם נסמכים עליהן לצורך אכיפה.

ב-Windows, הפנו למשתנה סביבה שמוגדר שם, כגון ${USERPROFILE} במקום ${HOME}.

שתי הרשימות מורחבות באופן שונה:

הסביבה המוצמדת והכללים בטבלה הזו דורשים Claude Code v2.1.219 או גרסה מאוחרת יותר.

#איך שרת מוערך

לפני טעינת שרת, כולל שרת מתוך managed-mcp.json, Claude Code מריץ את שלוש הבדיקות שלהלן לפי הסדר. הוא מריץ אותן שוב כאשר משתמש מתחבר מחדש לשרת או מפעיל מחדש שרת מושבת ב-/mcp. שרתי type: "sdk" בתוך התהליך, שהאפליקציה שהתחילה את ההפעלה רושמת, מדלגים על שלושתן.

1. מיזוג הרשימות. רשומות של רשימת היתר ורשימת חסימה מכל היקף הגדרות מתאחדות לרשימת היתר אחת ולרשימת חסימה אחת. כאשר allowManagedMcpServersOnly הוא true, נשמרת רק רשימת ההיתר המנוהלת. רשימת החסימה תמיד מתמזגת מכל היקף. כאשר קיים יותר ממקור מנוהל אחד, מפתחות שנקראים מכל מקור מנהל מציין אילו מהם מספקים את הרשימות של ההיקף המנוהל.
2. בדיקת רשימת החסימה. שרת שמתאים לרשומה כלשהי ברשימת החסימה, לפי URL, פקודה, או שם, נחסם. שום דבר אינו דורס התאמה לרשימת חסימה.
3. בדיקת רשימת ההיתר. יש שרתים שמדלגים על הבדיקה הזו. אם allowedMcpServers אינו מוגדר בשום מקום, כל שרת שעבר את רשימת החסימה נטען. אם הוא מוגדר, מה שהשרת חייב להתאים אליו תלוי בסוגו, כפי שמוצג בטבלה שלהלן.

#שרתים שמדלגים על בדיקת רשימת ההיתר

שלוש קבוצות של שרתים מדלגות על בדיקת רשימת ההיתר, בנוסף לשרתי type: "sdk" בתוך התהליך שמדלגים על כל שלוש הבדיקות:

• השרתים של הארגון עצמו: כל רשומת managedMcpServers, וכל רשומת managed-mcp.json שערכיה אינם משתמשים בהרחבת ${VAR} מחוץ ל-env.
• שרתים מובנים, כגון Claude in Chrome, שרת ide ש-Claude Code מתחבר אליו ב-VS Code או ב-IDE של JetBrains שפועל, ושרתים שה-CLI עצמו מגדיר.
• כלי Slack של הפעלת Claude Tag: השרתים שבהם היא משתמשת כדי לקרוא את השרשור ולפרסם את התשובות שלה נטענים בלי רשומה ברשימת ההיתר.

שרת managed-mcp.json שמשתמש בהרחבת ${VAR} בפקודה שלו, בארגומנטים, ב-URL, או בכותרות עדיין נבדק. Claude Code גם בודק כל שרת שמשתמש, תוסף, או claude.ai מוסיף, וכל שרת שמשתמש מעביר עם --mcp-config. עבור הגרסאות ששינו אילו שרתי managed-mcp.json נבדקים, ואיך למנוע משרת כזה להיטען, ראו איך רשימות היתר ורשימות חסימה חלות על הסט המנוהל.

#תצורת דוגמה

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

{
  "allowedMcpServers": [
    { "serverUrl": "https://api.githubcopilot.com/*" },
    { "serverUrl": "https://mcp.sentry.dev/*" },
    { "serverCommand": ["npx", "-y", "@modelcontextprotocol/server-filesystem", "."] },
    { "serverCommand": ["python", "/usr/local/bin/approved-server.py"] },
    { "serverUrl": "https://mcp.example.com/*" },
    { "serverUrl": "https://*.internal.example.com/*" }
  ],
  "deniedMcpServers": [
    { "serverName": "dangerous-server" },
    { "serverCommand": ["npx", "-y", "unapproved-package"] },
    { "serverUrl": "https://*.untrusted.example.com/*" }
  ]
}

• שורה 3: רשומת serverUrl הראשונה. ברגע שאחת קיימת, כל שרת מרוחק חייב להתאים לתבנית URL, כך שמשתמש אינו יכול להעביר שרת מרוחק שאינו ברשימה באמצעות מתן שם מותר לו.
• שורה 5: רשומת serverCommand הראשונה. אותה השפעה על שרתי stdio, כך שכל שרת מקומי חייב להתאים במדויק לפקודה שברשימה.
• שורה 11: רשומת serverName ברשימת החסימה. רשומות רשימת חסימה חלות תמיד, כך שכל שרת בשם dangerous-server נחסם בלי קשר לכתובת ה-URL או לפקודה שלו.

רשומת serverName ברשימת ההיתר הזו לעולם לא תתאים לשום דבר, מכיוון שלשני סוגי התעבורה כבר יש רשומות מחמירות יותר.

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

#רשימת היתר של URL בלבד

{
  "allowedMcpServers": [
    { "serverUrl": "https://mcp.example.com/*" },
    { "serverUrl": "https://*.internal.example.com/*" }
  ]
}

#רשימת היתר של פקודה בלבד

{
  "allowedMcpServers": [
    { "serverCommand": ["npx", "-y", "approved-package"] }
  ]
}

#רשימת היתר מעורבת של שם ופקודה

{
  "allowedMcpServers": [
    { "serverName": "github" },
    { "serverCommand": ["npx", "-y", "approved-package"] }
  ]
}

#רשימת היתר של שם בלבד

{
  "allowedMcpServers": [
    { "serverName": "github" },
    { "serverName": "internal-tool" }
  ]
}

#רשימת היתר עם דריסת רשימת חסימה

{
  "allowedMcpServers": [
    { "serverUrl": "https://*.example.com/*" }
  ],
  "deniedMcpServers": [
    { "serverUrl": "https://staging.example.com/*" }
  ]
}

#הגבלת רשימת ההיתר להגדרות מנוהלות בלבד

כדי להפוך את רשימת ההיתר המנוהלת ליחידה שחלה, הגדירו את allowManagedMcpServersOnly בקובץ ההגדרות המנוהלות:

{
  "allowManagedMcpServersOnly": true,
  "allowedMcpServers": [
    { "serverUrl": "https://api.githubcopilot.com/*" },
    { "serverUrl": "https://*.internal.example.com/*" }
  ]
}

כאשר allowManagedMcpServersOnly הוא true, רשימות היתר מהגדרות משתמש, מהגדרות פרויקט ומהגדרות מקומיות אינן נכללות. רשימת החסימה עדיין מתמזגת מכל היקף הגדרות, כך שמשתמשים תמיד יכולים לחסום שרתים עבור עצמם.

#איך ההגבלות מופיעות למשתמשים

למה שהמשתמשים רואים בהפעלה כאשר managed-mcp.json פרוס והסשן כולל גם שרתים של --mcp-config, ראו שליטה בלעדית עם managed-mcp.json. השתמשו בטבלה הזו כדי לזהות את הדיווחים האחרים וכדי לומר למשתמשים למה לצפות לפני שאתם מפיצים שינוי:

כששרת נעלם בשקט, המשתמש לא מקבל שום סימן שהסיבה היא מדיניות, אז אמרו למשתמשים המושפעים אילו שרתים חסומים כשאתם מפיצים הגבלה חדשה.

#מעקב אחרי שימוש ב MCP

כאשר אתם מגדירים ייצוא OpenTelemetry, Claude Code יכול לתעד אילו שרתי MCP ואילו כלים המשתמשים מפעילים. הגדירו OTEL_LOG_TOOL_DETAILS=1 כדי לכלול שמות של שרתי MCP ושל כלים באירועי כלים ובמוני העלות והאסימונים, ואז אגדו אותם ב collector שלכם כדי לראות לאילו שרתים המשתמשים שלכם מתחברים בפועל. ראו ניטור כדי להגדיר את רכיב הייצוא ולסכמת האירועים המלאה.

#סיכום תצורה

כל קובץ וכל הגדרה שהעמוד הזה מכסה, מה הם שולטים, ואיך להפיץ אותם:

#משאבים קשורים

• החליטו מה לאכוף: הגבלות MCP לצד כללי הרשאות, ארגז חול, ושאר בקרות הניהול
• חיבור Claude Code לכלים דרך MCP: מדריך MCP המלא, כולל תעבורות, היקפים ואימות
• הגדרות: היררכיית ההגדרות ואיך הגדרות מנוהלות מקבלות קדימות
• הגדרות שמנוהלות בשרת: הפצת allowedMcpServers ו deniedMcpServers מקונסולת הניהול של claude.ai
• אבטחה: מודל האיומים שהבקרות האלה מגנות מפניו
• מדריך מנהל Claude Enterprise: SSO, SCIM, ניהול מושבים, ומדריך פריסה