אימות לשירותים חיצוניים באמצעות הזהות של הסוכן

התכונה "זהות הסוכן" מאפשרת לסוכנים ב- Google Cloud להשתמש בזהות שלהם כדי לאמת את עצמם בשירותים חיצוניים ובעומסי עבודה שמתארחים ב-Cloud Run או ב-Google Kubernetes Engine ‏ (GKE). באמצעות טוקנים של מזהי OpenID Connect ‏ (OIDC), אתם יכולים לחבר נציגים לפלטפורמות ענן של צד שלישי כמו Amazon Web Services ‏ (AWS) ו-Microsoft Azure, לממשקי API בהתאמה אישית, לשערי API ולמערכות בקצה העורפי בארגון.

כשהסוכן פועל לפי הסמכות שלו, Agent Identity מנפיק טוקן של מזהה OIDC, שהוא אסימון אינטרנט מסוג JSON‏ (JWT) שמאשר את זהות ה-SPIFFE של הסוכן, ונחתם על ידי מפתחות המנפיק של מתחם האמון של הסוכן (מאגר הזהויות המנוהל של עומסי העבודה). מערכות חיצוניות יכולות לאמת את הטוקנים האלה של המזהים בלי פרטי כניסה או ערכות SDK שלGoogle Cloud , באמצעות נקודות קצה ציבוריות שמתארחות ב-Security Token Service שלGoogle Cloud :

  • נקודת קצה (endpoint) של OpenID Connect Discovery 1.0 (/.well-known/openid-configuration) שמפרסמת את המטא-נתונים של ספק ה-OpenID ואת נקודת הקצה של המפתח הציבורי (jwks_uri).
  • נקודת קצה (endpoint) של JSON Web Key Set‏ (JWKS) (/openid/jwks) שמספקת את המפתחות הציבוריים הפעילים שמשמשים לאימות חתימות על טוקנים של מזהי נציגים.

כדי לאמת את הנציג בממשקי API ובמשאבים של Google Cloud באמצעות הזהות שלו, קראו את המאמר אימות ב- Google Cloud באמצעות הזהות של הנציג. כדי לגשת לשירותים בשם משתמש קצה, קראו את המאמר אימות באמצעות OAuth תלת-רגלי עם מנהל אימות.

לפני שמתחילים

  1. מוודאים שבחרתם בשיטת האימות הנכונה. בסקירה הכללית על Agent Identity מוסבר איך פועלים זהויות SPIFFE, מתחמי אמון ופרטי הכניסה של הסוכן.
  2. יוצרים ופורסים סוכן עם Agent Identity מופעל.
  3. חשוב לוודא שהשירות החיצוני או ספק הזהויות עומדים בדרישות הבאות:

  4. מזהים את ערכי ההגדרות הבאים של הנציג ושל השירות החיצוני שאליו רוצים לשלוח את הבקשה:

    • ‫Issuer URL (iss claim): כתובת ה-URL של מנפיק מאגר הזהויות של עומסי העבודה בארגון (https://sts.googleapis.com/v1/organizations/ORGANIZATION_ID/locations/global/workloadIdentityPools/TRUST_DOMAIN) או בפרויקט (https://sts.googleapis.com/v1/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/TRUST_DOMAIN).
    • ‫Allowed audience (aud claim): ה-URI של הקהל שהשירות החיצוני או ספק הזהויות מצפים לו כשהם מאמתים טוקנים של מזהים.
  5. מוודאים שיש לכם את התפקידים הנדרשים כדי להשלים את המשימה.

התפקידים הנדרשים

כדי לקבל את ההרשאות שנדרשות לפריסת נציג עם Agent Identity, בקשו מהאדמין להקצות לכם את התפקידים הבאים ב-IAM בפרויקט:

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

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

ההרשאות הנדרשות

כדי לפרוס סוכן עם Agent Identity, צריך את ההרשאות הבאות:

  • פריסת סוכן ב-Agent Runtime ב-Gemini Enterprise Agent Platform:
    • aiplatform.reasoningEngines.create
    • aiplatform.reasoningEngines.update
  • פורסים שירות של סוכן ב-Cloud Run:
    • run.services.create
    • run.services.update

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

קבלת טוקן של מזהה OIDC לסוכן

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

  1. הגדרת הסוכן באמצעות Agent Identity
  2. בקשת טוקן של מזהה של OIDC בקוד אפליקציה

הגדרת הסוכן באמצעות Agent Identity

מפעילים את Agent Identity כשפורסים את הסוכן:

  • אם אתם פורסים את הסוכן ב-Agent Runtime ב-Gemini Enterprise Agent Platform, הגדירו את identity_type לערך AGENT_IDENTITY:

    remote_app = client.agent_engines.create(
        agent=app,
        config={
            "identity_type": types.IdentityType.AGENT_IDENTITY,
            "requirements": ["google-cloud-aiplatform[agent_engines,adk]"],
        },
    )
    
  • אם פורסים שירות של סוכן בקונטיינר ב-Cloud Run, מעבירים את הדגל --identity-type=agent-identity:

    gcloud run deploy SERVICE_NAME \
        --image=IMAGE_URL \
        --identity-type=agent-identity \
        --no-allow-unauthenticated

    מחליפים את מה שכתוב בשדות הבאים:

    • ‫SERVICE_NAME: השם של שירות Cloud Run.
    • ‫IMAGE_URL: כתובת ה-URL של קובץ האימג' של הקונטיינר של הנציג.

בקשה של טוקן מזהה של OIDC בקוד האפליקציה

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

כברירת מחדל, ספריות הלקוח הנתמכות של Google Auth מקשרות באופן קריפטוגרפי טוקנים של מזהה OIDC לאישור X.509 הייחודי של הסוכן, על ידי הכללת טביעת האצבע של האישור בהצהרה cnf (x5t#S256) של הטוקן. שירותים שמקבלים את הטענה יכולים לאמת אותה מול אישור הלקוח שמוצג במהלך לחיצת יד של Mutual TLS ‏ (mTLS), או להתעלם מהטענה אם הם לא אוכפים קישור אישורים.

‫Cloud Run אוכף באופן אוטומטי את קישור האישור כשהטענה cnf קיימת בטוקן של מזהה. אם הנציג שלכם קורא לשירות Cloud Run באמצעות אסימון מזהה מקושר, צריך לקרוא לנקודת הקצה (*.mtls.run.app) של mTLS דרך חיבור mTLS. כדי להמשיך לשלוח קריאות לכתובת URL רגילה של *.run.app, צריך לבטל את ההסכמה לקישור אישורים לכל בקשה (לדוגמה, על ידי הגדרת bind_id_token=False ב-Python) או בכל סביבת זמן הריצה באמצעות GOOGLE_API_ENABLE_RUNTIME_BOUND_TOKEN=false. במאמר ביטול ההסכמה לשימוש באסימונים שקשורים לאישורים מפורטות גרסאות הספרייה הנתמכות ומוצגות דוגמאות.

כשקוראים לנקודת קצה (endpoint) שאוכפת קישור אישורים דרך mTLS, צריך להגדיר את סשן הלקוח כך שיציג את אישור ה-X.509 של הסוכן במהלך לחיצת היד של mTLS (לדוגמה, על ידי קריאה ל-authed_session.configure_mtls_channel() ב-Python).

בדוגמאות הבאות נעשה שימוש בספרייה google-auth כדי לבקש טוקן של מזהה של OIDC שקשור לתעודה, להגדיר את ערוץ ה-mTLS (אופציונלי) ולצרף את הטוקן כאסימון Bearer בבקשה יוצאת:

Python

from google.auth.transport.requests import AuthorizedSession
from google.oauth2 import id_token

# 1. Specify the audience expected by the external receiver
# (for example, AWS Bedrock AgentCore or your external service URL).
target_audience = "https://EXTERNAL_SERVICE_AUDIENCE"

# 2. Create ID token credentials and an AuthorizedSession, which handles
# local token caching, automatic renewal before expiry, and the
# Bearer header.
credentials = id_token.fetch_id_token_credentials(audience=target_audience)
authed_session = AuthorizedSession(credentials)

# 3. Send the authenticated request to the external service.
response = authed_session.post(
    "https://EXTERNAL_SERVICE_ENDPOINT",
    json={"prompt": "Hello from Agent"},
)

מחליפים את מה שכתוב בשדות הבאים:

  • ‫EXTERNAL_SERVICE_AUDIENCE: ה-URI של הקהל שצפוי על ידי השירות המקבל (לדוגמה, bedrock.us-east-1.amazonaws.com או api.example.com).
  • ‫EXTERNAL_SERVICE_ENDPOINT: כתובת ה-URL של ה-API החיצוני או של נקודת הקצה בקצה העורפי שהנציג קורא לה.

‫Python‏ (mTLS)

from google.auth.transport.requests import AuthorizedSession
from google.oauth2 import id_token

# 1. Specify the audience expected by the receiving service
# (for example, a regional Cloud Run mTLS URL or an on-premises mTLS endpoint).
target_audience = "https://EXTERNAL_SERVICE_AUDIENCE"

# 2. Create certificate-bound ID token credentials and configure the mTLS
# channel to present the agent's X.509 certificate.
credentials = id_token.fetch_id_token_credentials(audience=target_audience)
authed_session = AuthorizedSession(credentials)
authed_session.configure_mtls_channel()

# 3. Send the authenticated request over mTLS.
response = authed_session.post(
    "https://EXTERNAL_SERVICE_ENDPOINT",
    json={"prompt": "Hello from Agent"},
)

מחליפים את מה שכתוב בשדות הבאים:

  • ‫EXTERNAL_SERVICE_AUDIENCE: ה-URI של הקהל שצפוי על ידי השירות המקבל (לדוגמה, כתובת URL אזורית של Cloud Run mTLS או api.example.com).
  • ‫EXTERNAL_SERVICE_ENDPOINT: כתובת ה-URL של ה-API של mTLS או של נקודת הקצה בקצה העורפי שהנציג קורא לה.

במאמר קבלת טוקן של מזהה תוכלו לקרוא הוראות ודוגמאות לספריות לקוח בשפות אחרות, כמו Go, ‏ Node.js ו-Java. ספריות הלקוח בשפות האלה תומכות ב---identity-type=agent-identity. ספריות שתומכות בטוקנים של מזהים שמקושרים לאישורים מקשרות את הטוקנים כברירת מחדל, ומאפשרות לבטל את ההסכמה לבקשות ספציפיות.

אימות טוקנים של מזהי Agent Identity

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

שימוש באיחוד מובנה של שירותי אימות הזהות של עומסי עבודה

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

  • ‫Cloud Run: אם השירות המקבל פועל ב-Cloud Run עם תעבורת נתונים נכנסת מאומתת (--no-allow-unauthenticated), Cloud Run מאמת את אסימוני Agent Identity הנכנסים בשכבת תעבורת הנתונים הנכנסת. כשהאסימון כולל את ההצהרה cnf, מגדירים את הסוכן שמבצע את הקריאה כך שיטרגט את כתובת ה-URL האזורית של mTLS של השירות שמקבל את הקריאה (https://SERVICE_NAME-PROJECT_NUMBER.REGION.mtls.run.app), כדי ש-Cloud Run יוכל לאמת את אישור הלקוח במהלך לחיצת היד של mTLS. מקצים לסוכן השירות שמבצע את הקריאה את התפקיד Cloud Run Invoker‏ (roles/run.invoker) בשירות שמקבל את הקריאה. מידע נוסף זמין במאמר אימות לשרתי MCP ב-Cloud Run.

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

  • Amazon Bedrock: מגדירים אימות JWT נכנס על ידי ציון כתובת ה-URL של מסמך Discovery או כתובת ה-URL של המנפיק של Google Cloud Security Token Service, ו הקהל הצפוי. הוראות מופיעות במאמר הגדרת מאמת JWT נכנס במסמכי התיעוד של AWS.

  • ‫Microsoft Entra ID: מגדירים פרטי כניסה של זהות מאוחדת בתרחיש Other issuer. מציינים את כתובת ה-URL של המנפיק של Google Cloud Security Token Service, את הקהל הצפוי ואת מזהה הנושא (הטענה (claim) של sub). להוראות, קראו את המאמר יצירת יחסי אמון בין אפליקציה לבין ספק זהויות חיצוני במסמכי התיעוד של Microsoft Learn.

אימות טוקנים באופן פרוגרמטי

אם הנציג שולח בקשות ל-API בהתאמה אישית, למיקרו-שירות, ל-API Gateway או לעומס עבודה מקומי, השירות שמקבל את הבקשה צריך לאמת את הטוקן של מזהה ה-OIDC לפני שהוא נותן גישה. בדרך כלל הנציג מעביר את האסימון הזה בכותרת ה-HTTP של Authorization: Bearer TOKEN.

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

  1. חילוץ ואימות של כתובת ה-URL של מנפיק האסימון
  2. איתור מפתחות החתימה הציבוריים ושמירה שלהם במטמון
  3. אימות החתימה וההצהרות של האסימון
  4. אופציונלי: אימות של קישור האישור (הצהרת cnf)
  5. אישור זהות ה-SPIFFE של הסוכן

חילוץ ואימות של כתובת ה-URL של מנפיק הטוקן

כשמגיעה בקשה, קוראים את המטען הייעודי (payload) של ה-JWT שלא אומת כדי לחלץ את ההצהרה iss (המנפיק). הטענה הזו מכילה את כתובת ה-URL של מאגר הזהויות של עומסי העבודה של מתחם האמון של הנציג. כתובת ה-URL הזו משמשת ככתובת ה-URL הבסיסית למסמך ה-Discovery ולמפתחות החתימה הציבוריים.

לפני ששולחים בקשות לאחזור מהרשת, מוודאים שהדרישה iss תואמת לכתובת ה-URL הצפויה של מאגר הזהויות של עומסי העבודה של שירות אסימוני האבטחה (STS) ב- Google Cloud בארגון או בפרויקט:

  • דומיינים מהימנים ברמת הארגון:

    https://sts.googleapis.com/v1/organizations/ORGANIZATION_ID/locations/global/workloadIdentityPools/TRUST_DOMAIN

    לדוגמה, בארגון עם המזהה 123456789012, הערך של TRUST_DOMAIN הוא agents.global.org-123456789012.system.id.goog.

  • מתחמי אמון ברמת הפרויקט (לפרויקטים בלי ארגון):

    https://sts.googleapis.com/v1/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/TRUST_DOMAIN

    לדוגמה, בפרויקט עם המספר 9876543210, הערך של TRUST_DOMAIN הוא agents.global.proj-9876543210.system.id.goog.

איתור מפתחות החתימה הציבוריים ושמירה שלהם במטמון

אחרי שמאמתים את כתובת ה-URL של המנפיק, מאחזרים את מפתחות החתימה הציבוריים מ Google Cloud שירות אסימון האבטחה ושומרים אותם במטמון:

  1. שליחת שאילתה לנקודת הקצה של OpenID Connect Discovery: מוסיפים את /.well-known/openid-configuration לכתובת ה-URL הבסיסית של המנפיק ושולחים בקשת HTTP GET לא מאומתת:

    לפני שמשתמשים בנתוני הבקשה, צריך להחליף את הנתונים הבאים:

    • ‫ORGANIZATION_ID: מזהה הארגון ב- Google Cloud. בפרויקט בלי ארגון, מחליפים את organizations/ORGANIZATION_ID ב-projects/PROJECT_NUMBER.
    • ‫TRUST_DOMAIN: מזהה מאגר הזהויות של עומסי העבודה של מתחם האמון של הנציג (לדוגמה, agents.global.org-123456789012.system.id.goog).

    ה-method של ה-HTTP וכתובת ה-URL:

    GET https://sts.googleapis.com/v1/organizations/ORGANIZATION_ID/locations/global/workloadIdentityPools/TRUST_DOMAIN/.well-known/openid-configuration

    כדי לשלוח את הבקשה צריך להרחיב אחת מהאפשרויות הבאות:

    אם הבקשה תצליח, יוחזר סטטוס HTTP 200 OK ואובייקט JSON שמכיל את המטא-נתונים של ספק OpenID, כולל השדה jwks_uri:

    {
      "issuer": "https://sts.googleapis.com/v1/organizations/123456789012/locations/global/workloadIdentityPools/agents.global.org-123456789012.system.id.goog",
      "jwks_uri": "https://sts.googleapis.com/v1/organizations/123456789012/locations/global/workloadIdentityPools/agents.global.org-123456789012.system.id.goog/openid/jwks",
      "authorization_endpoint": "https://sts.googleapis.com/v1/organizations/123456789012/locations/global/workloadIdentityPools/agents.global.org-123456789012.system.id.goog/authorize",
      "token_endpoint": "https://sts.googleapis.com/v1/organizations/123456789012/locations/global/workloadIdentityPools/agents.global.org-123456789012.system.id.goog/token",
      "response_types_supported": [
        "id_token"
      ],
      "subject_types_supported": [
        "public"
      ],
      "id_token_signing_alg_values_supported": [
        "RS256"
      ]
    }
    
  2. שליחת שאילתה לנקודת הקצה של JSON Web Key Set‏ (JWKS): שולחים בקשת HTTP GET לא מאומתת לכתובת ה-URL של jwks_uri שהוחזרה במטא-נתונים של ספק ה-OpenID:

    לפני שמשתמשים בנתוני הבקשה, צריך להחליף את הנתונים הבאים:

    • ‫ORGANIZATION_ID: מזהה הארגון ב- Google Cloud. בפרויקט בלי ארגון, מחליפים את organizations/ORGANIZATION_ID ב-projects/PROJECT_NUMBER.
    • ‫TRUST_DOMAIN: מזהה מאגר הזהויות של עומסי העבודה של מתחם האמון של הנציג (לדוגמה, agents.global.org-123456789012.system.id.goog).

    ה-method של ה-HTTP וכתובת ה-URL:

    GET https://sts.googleapis.com/v1/organizations/ORGANIZATION_ID/locations/global/workloadIdentityPools/TRUST_DOMAIN/openid/jwks

    כדי לשלוח את הבקשה צריך להרחיב אחת מהאפשרויות הבאות:

    בקשה מוצלחת מחזירה סטטוס HTTP 200 OK ואובייקט JSON שמכיל מערך של מפתחות ציבוריים בפורמט לפי RFC 7517:

    {
      "keys": [
        {
          "kty": "RSA",
          "use": "sig",
          "alg": "RS256",
          "kid": "4d1933f8e6c4e0b512c140989f6655c68997...",
          "n": "uQn4zN_1mQ0VpGv82-Wp3w...",
          "e": "AQAB"
        }
      ]
    }
    
  3. שמירת מסמך ה-Discovery והמפתחות במטמון: התגובות מנקודת הקצה של OpenID Connect Discovery ומנקודת הקצה של JWKS כוללות את כותרת המטמון הבאה של HTTP:

    Cache-Control: public, max-age=86400, must-revalidate
    

    כדי לשפר את ביצועי האימות ולהימנע מהגבלת קצב של יצירת בקשות, כדאי לשמור במטמון את מסמך ה-Discovery ואת ה-JWKS למשך עד 24 שעות (86400 שניות).

    ‫Google Cloud מבצע רוטציה תקופתית של מפתחות החתימה הפרטיים והציבוריים של מאגרי הזהויות של עומסי העבודה. אם המאמת מקבל אסימון נכנס עם kid (מזהה מפתח) שלא נמצא במטמון המפתחות המקומי שלו, צריך לאחזר JWKS חדש מנקודת הקצה /openid/jwks לפני שדוחים את האסימון.

    אם נתקלתם בשגיאות HTTP כששלחתם שאילתות לנקודות הקצה של הגילוי או של JWKS, קראו את המאמר פתרון בעיות באימות של Agent Identity.

אימות החתימה והטענות של האסימון

כדי לאמת באופן קריפטוגרפי את החתימה של האסימון ואת ההצהרות של ה-JWT, צריך להשתמש בספריית אימות סטנדרטית של OIDC או JWT (כמו Google Tink) ולבצע את הפעולות הבאות:

  1. חתימה: מאתרים את המפתח הציבורי ב-JWKS שנשמר במטמון, שתואם ל-kid (מזהה המפתח) בכותרת ה-JWT. מאמתים את החתימה באמצעות האלגוריתם שצוין בשדה alg (RS256). כדי לשמור על תאימות קדימה, בודקים את השדות alg ו-kty ב-JWKS באופן דינמי במקום להגדיר באופן קשיח את סוגי האלגוריתמים.
  2. ‫Issuer (iss): מוודאים שהדרישה iss תואמת לכתובת ה-URL המהימנה של מנפיק מאגר הזהויות של עומסי העבודה ב-Google Cloud של מתחם האמון.
  3. קהל (aud): מוודאים שהטענה aud תואמת למזהה הקהל שהוגדר בשירות.
  4. זמן ההנפקה (iat) וזמן התפוגה (exp): מוודאים שההצהרה iat היא בעבר, ושהזמן הנוכחי מוקדם יותר מההצהרה exp (עם סבילות קטנה להפרש זמנים, כמו דקה או שתיים).

בדוגמה הבאה נעשה שימוש ב-Google Tink (tink.jwt) כדי לאמת טוקן של מזהה Agent Identity מול מטען ייעודי (payload) של JWKS JSON:

Python

import tink
from tink import jwt

# Initialize Tink JWT signature primitives (call once at application startup).
jwt.register_jwt_signature()


def verify_agent_identity_token(
    token: str,
    jwks_json: str,
    expected_issuer: str,
    expected_audience: str,
) -> jwt.VerifiedJwt:
    """Verifies an Agent Identity JWT against a JWKS JSON string using Tink.

    Args:
        token: The compact serialized JWT string.
        jwks_json: The JWKS JSON string fetched from the STS pool endpoint.
        expected_issuer: The expected token issuer ('iss' claim).
        expected_audience: The expected token audience ('aud' claim).

    Returns:
        jwt.VerifiedJwt: The verified JWT claims object.

    Raises:
        tink.TinkError: If the JWKS cannot be parsed, the key is not found,
            or token validation (signature, issuer, audience, expiration) fails.
    """
    # 1. Convert the JWKS JSON into a Tink public KeysetHandle.
    keyset_handle = jwt.jwk_set_to_public_keyset_handle(jwks_json)

    # 2. Instantiate the Tink JwtPublicKeyVerify primitive.
    jwt_verifier = keyset_handle.primitive(jwt.JwtPublicKeyVerify)

    # 3. Configure expected validation rules (issuer, audience, expiration).
    # Google Cloud STS sets 'typ': 'JWT' in the header, so
    # expected_type_header="JWT" is required.
    validator = jwt.new_validator(
        expected_issuer=expected_issuer,
        expected_audience=expected_audience,
        expected_type_header="JWT",
        allow_missing_expiration=False,
    )

    # 4. Cryptographically verify the signature and standard OIDC claims.
    return jwt_verifier.verify_and_decode(token, validator)

אופציונלי: אימות הקישור בין האישור למכשיר (טענת נכוֹנוּת (claim) של cnf)

אם השירות המקבל אוכף קישור אישורים באמצעות mTLS, צריך לאמת את ההצהרה cnf (x5t#S256) מול אישור הלקוח שהוצג במהלך לחיצת היד של mTLS:

  1. סיום של אימות TLS בו-זמני (mTLS): מגדירים את השרת או את שרת ה-proxy של Ingress כך שיבקש ויאמת את אישור ה-X.509 של הנציג במהלך לחיצת היד בפרוטוקול TLS, בהתאם ל-TLS 1.3 (RFC 9846).
  2. חישוב טביעת אצבע לאישור (x5t#S256): חילוץ אישור הלקוח מסוג X.509 של העלה הירוק מחיבור ה-mTLS. מחשבים את גיבוב ה-SHA-256 על הבייטים בקידוד DER, ומקודדים את התקציר ב-base64url בלי ריפוד =.
  3. אימות הטענה cnf (x5t#S256): בודקים את המטען הייעודי (payload) המאומת של JWT לאובייקט cnf ({"cnf": {"x5t#S256": "FINGERPRINT"}}) ומוודאים שהערך של x5t#S256 תואם לטביעת אצבע לאישור הלקוח, בהתאם ל-RFC 8705 סעיף 6.1. אם הגורם ששלח את הבקשה לא הציג אישור לקוח ב-mTLS או אם טביעות האצבע לא תואמות, דוחים את הבקשה עם תשובת HTTP 401 Unauthorized.

אישור זהות ה-SPIFFE של הסוכן

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

התביעה sub מכילה את מזהה ה-SPIFFE הייחודי של הנציג, לדוגמה:

  spiffe://agents.global.org-123456789012.system.id.goog/resources/aiplatform/projects/9876543210/locations/us-central1/reasoningEngines/my-test-agent

בלוגיקת ההרשאה של השירות, משווים את ההצהרה המאומתת sub לרשימת היתרים של מזהי SPIFFE של סוכנים מהימנים (או תחיליות של דומיינים מהימנים) לפני שנותנים גישה למשאבים מוגנים.

המאמרים הבאים