אבטחת מערכת מרובת סוכנים

1. מבוא

סקירה כללית

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

ה-Lab הזה מתמקד בחיזוק המערכת על ידי טיפול בפערים האלה באבטחה. חשיפת נקודות קצה של סוכנים הופכת אותן למטרות להחדרת הנחיות, למניעת שירות ולניצול לרעה מסוגים אחרים. סוכנים שמקיימים אינטראקציה עם משתמשים עלולים לעבד פרטים אישיים רגישים מזהים (PII), בעוד שסוכנים שסורקים את האינטרנט עלולים להטמיע תוכן פוגעני או ליפול קורבן להחדרת הנחיות עקיפה. כדי להתמודד עם האיומים האלה, תטמיעו אסטרטגיית הגנה נרחבת באמצעות כלי האבטחה של Google Cloud, כולל Model Armor ו-Sensitive Data Protection, ותיישמו שיטות מומלצות לאבטחה כמו IAM עם הרשאות מינימליות ותקשורת מאומתת ברשת.

הפעולות שתבצעו:

  • הגדרת מדיניות אבטחה: יצירת תבניות של Sensitive Data Protection ‏ (SDP) כדי לזהות ולערוך פרטים אישיים מזהים (PII).
  • שילוב של Application Safety: משנים את הקצה העורפי כדי ליירט ולנקות את ההנחיות של המשתמשים באמצעות Model Armor לפני שהן מגיעות לסוכנים.
  • אימות ההגנה: פורסים את האפליקציה המאובטחת ומריצים תרחישים של צוות אדום כדי לוודא שהחדרות של הנחיות ודליפות של מידע אישי רגיש נחסמות.
  • הטמעה של מדיניות כקוד (אופציונלי): אפשר להשתמש ב-Terraform כדי לנהל את התבניות של הגנה מוגברת על המודל ו-SDP, וכך להבטיח מסנני אבטחה או אמצעי הגנה עקביים בכל הסביבות.

מה תלמדו

  • איך מגדירים את Sensitive Data Protection ‏ (SDP) ב-Google Cloud כדי לזהות ולהסתיר מידע רגיש.
  • הדרכה: איך יוצרים ופורסים תבניות של הגנה מוגברת על המודל באמצעות Terraform.
  • התבנית 'הגנה לעומק' לאבטחת סוכני AI גנרטיבי בשכבת האפליקציה.
  • איך מבצעים ביקורת ומאמתים אמצעי בקרה לאבטחה באמצעות טכניקות של צוות אדום.

2. הגדרה

הגדרות אישיות

  1. מוודאים שהתחברתם לחשבון. מריצים את הפקודה הבאה כדי לקבל את חשבון gcloud הנוכחי:
    ‫
    gcloud config get-value account
    אם לא נכנסתם לחשבון, מריצים את הפקודה הבאה:
    gcloud auth login --update-adc
  2. מגדירים פרויקט פעיל ל-CLI של gcloud.מריצים את הפקודה הבאה כדי לקבל את הפרויקט הנוכחי של gcloud:
    ‫
    gcloud config get-value project
    אם היא לא מוגדרת, מריצים את הפקודה הבאה:
    ‫
    gcloud config set project YOUR_PROJECT_ID
    מחליפים את YOUR_PROJECT_ID במזהה הפרויקט.
  3. מפעילים את ה-API ל-Cloud Run, להגנה מוגברת על המודל, למניעת אובדן נתונים, ל-Artifact Registry, ל-Cloud Build ול-IAM Credentials.
    gcloud services enable --project $(gcloud config get-value project) \
      aiplatform.googleapis.com \
      modelarmor.googleapis.com \
      dlp.googleapis.com \
      run.googleapis.com \
      artifactregistry.googleapis.com \
      cloudbuild.googleapis.com \
      iamcredentials.googleapis.com
  4. מגדירים את אזור ברירת המחדל שבו ייפרסו שירותי Cloud Run.
    gcloud config set run/region us-central1
    חשוב להשתמש ב-us-central1 כדי לגשת להגנה מוגברת על המודל ולקבל דוגמאות עקביות. כאן אפשר לראות את האזורים שבהם Model Armor זמין.

קוד ויחסי תלות

  1. משכפלים את קוד ההתחלה ועוברים לספריית השורש של הפרויקט.
    git clone https://github.com/h3xar0n/prai-roadshow-lab-3-starter
cd prai-roadshow-lab-3-starter
    כדי להפעיל סביבת עבודה של Cloud Shell, מריצים את הפקודה הבאה:
    cloudshell workspace .
    משתמשים באפשרות Terminal > New Terminal כדי לפתוח טרמינל חדש.
  2. כדי ליצור קובץ .env, מזינים את הפקודות הבאות בטרמינל:
    echo "GOOGLE_GENAI_USE_VERTEXAI=true" > .env
echo "GOOGLE_CLOUD_PROJECT=$(gcloud config get-value project -q)" >> .env
echo "GOOGLE_CLOUD_REGION=$(gcloud config get-value run/region -q)" >> .env
echo "GOOGLE_CLOUD_LOCATION=global" >> .env
    ב-Cloud Shell Editor, משתמשים באפשרות View > Toggle Hidden Files (תצוגה > החלפת קבצים מוסתרים) כדי לראות קבצים מוסתרים, כמו .env.
  3. כדי להתקין את יחסי התלות, מזינים את הפקודות הבאות בטרמינל:
    uv sync

3. יצירת תבניות של Sensitive Data Protection

התכונה 'מתקדם' של Model Armor להגנה על מידע רגיש משולבת עם Cloud DLP (Sensitive Data Protection) כדי לבדוק תוכן ולהסיר ממנו פרטים מזהים. כדי להשתמש בו לצורך צנזורה, צריך קודם ליצור תבניות של Inspect ושל הסרת פרטי הזיהוי, שבהן מציינים אילו סוגים של מידע אישי רגיש להפוך ואיך להפוך אותם.

Sensitive Data Protection

יצירת תבנית בדיקה

כדי לזהות סוגים שונים של מידע אישי רגיש, Sensitive Data Protection משתמש במזהי infoType. יש יותר מ-150 גלאים מובנים שמשתמשים בשיטות שונות לזיהוי, כולל התאמת תבניות (ביטוי רגולרי (regex)), מילונים ואותות מבוססי-הקשר. עבור סוגים מסוימים כמו מספרי כרטיס אשראי או תעודות מזהות ממשלתיות, הגלאים האלה לא מסתמכים רק על התאמת תבניות, אלא גם מאמתים סיכומי ביקורת (checksum) כדי לצמצם את מספר התוצאות החיוביות הכוזבות. הגלאים האלה מכסים פרטים אישיים מזהים (PII) כמו שמות וכתובות, אבל גם פרטי כניסה כמו מפתחות API או אסימוני אימות, וזה שימושי במיוחד למניעת חשיפה של סוכנים שמבצעים אינטראקציה עם קוד או קוראים קוד.

  1. במסוף Google Cloud, עוברים אל Security (אבטחה) > Sensitive Data Protection (הגנה על מידע אישי רגיש).
  2. בתפריט הניווט, בוחרים באפשרות הגדרה > תבניות.
  3. לוחצים על יצירת תבנית.
  4. מגדירים את התבנית:
    • סוג התבנית: Inspect
    • מזהה התבנית: sensitive-data-inspector
    • סוג המיקום: Region
    • אזור: us-central1 (הפרמטר הזה נדרש כדי לעבוד עם Model Armor).
  5. לוחצים על המשך.
  6. בקטע הגדרת זיהוי, לוחצים על ניהול סוגי מידע.
  7. משתמשים במסנן כדי לחפש את infoTypes הבאים ומסמנים את התיבה לצד כל אחד מהם:
    • CREDIT_CARD_NUMBER
    • GOVERNMENT_ID
    • PERSON_NAME
    • EMAIL_ADDRESS
    • STREET_ADDRESS
    • SECURITY_DATA
  8. בוחרים נושאים נוספים שמעניינים אתכם ולוחצים על סיום.
  9. בצד שמאל, אפשר לבדוק מה יהיו הקלט והפלט עבור סוגים שונים של מידע רגיש שבחרתם.

    בדיקת תבנית

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

יצירת תבנית לביטול הזיהוי

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

התכונה Sensitive Data Protection תומכת בשיטות רבות ושונות של טרנספורמציה. יכול להיות שתרצו לצנזר פרטים אישיים מזהים כמו כתובות רחוב באופן מלא על ידי החלפתם בתווים כמו [REDACTED], אבל כשמדובר במספר כרטיס אשראי או במספר תעודת זהות, יכול להיות שתעדיפו להסתיר אותו באמצעות תו כמו #, תוך השארת 4 הספרות האחרונות גלויות לצורכי זיהוי. רשימה מלאה של שיטות טרנספורמציה שמאפשרות לאזן בין אבטחה לבין שימושיות מופיעה במאמר טכניקות להסרת פרטים מזהים.

  1. במסוף Google Cloud, עוברים אל Security (אבטחה) > Sensitive Data Protection (הגנה על מידע אישי רגיש).
  2. בתפריט הניווט, בוחרים באפשרות הגדרה > תבניות > הסרת פרטים מזהים.
  3. לוחצים על יצירת תבנית.
  4. מגדירים את התבנית:
    • סוג התבנית: De-identify
    • סוג טרנספורמציית הנתונים: InfoType
    • מזהה התבנית: sensitive-data-redactor
    • סוג המיקום: Region
    • אזור: us-central1 (הפרמטר הזה נדרש כדי לעבוד עם Model Armor).
  5. לוחצים על המשך.
  6. בקטע Configure de-identification, מגדירים כמה כללים. כללים לגבי סוגי מידע ספציפיים מבטלים את כלל ברירת המחדל.
  7. מגדירים את כלל ההמרה הראשון:
    • טרנספורמציה: Mask with character
    • תו למיסוך: #
    • תווים להתעלמות > ציון תווים להתעלמות: US Punctuation...
    • מספר התווים שיוסתר: 12
    • ‫infoTypes to transform: Specific infoTypes
    • לוחצים על ניהול סוגי מידע.
    • מחפשים ואז מסמנים את התיבה לצד CREDIT_CARD_NUMBER
    • לוחצים על סיום.
    • בודקים את דוגמת הקלט ואת הדוגמה שעברה טרנספורמציה כדי לוודא שרק ארבע הספרות האחרונות לא מוסתרות, כי בחרתם להתעלם מ- ולהתמקד ב-12 התווים הראשונים של מספר כרטיס בן 16 ספרות.
  8. לוחצים על + הוספת כלל המרה ומגדירים:
    • טרנספורמציה: Replace
    • סוג ההחלפה: String
    • ערך מחרוזת: [redacted] (או כל מחרוזת אחרת שרוצים להשתמש בה)
    • ‫infoTypes to transform: Any detected infoTypes...
  9. לוחצים על יצירה כדי לשמור את תבנית הסרת הפרטים המזהים.
  10. לוחצים על Test ובוחרים את תבנית הבדיקה שיצרתם קודם, שמסתיימת ב-/sensitive-data-inspector. בבדיקה הזו ישולבו סוגי המידע מהתבנית לבדיקה עם ההמרות מהתבנית להסרת פרטים מזהים.

בדיקת תבנית להסרת פרטי זיהוי

עכשיו אפשר להפעיל את התבניות האלה באמצעות Model Armor. כדי לקבל מידע נוסף על השימוש ב-Sensitive Data Protection לכל דבר, מסריקות שבועיות של מאגרי מידע ועד לביקורות ב-BigQuery, וכדי לבדוק אותו בסוגים שונים של קבצים כמו תמונות ו-CSV, אפשר לעיין במעבדה Securing Data Used for AI Applications (אבטחת נתונים שמשמשים ליישומי AI).

כדי ליצור את תבניות ה-SDP האלה באמצעות Terraform, אפשר לעיין בקטע 'נספח' בשיעור ה-Lab הזה.

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

עכשיו ניצור תבנית הגנה מוגברת על המודל שמשתמשת בתבנית ה-SDP שיצרתם כדי לטפל במידע אישי רגיש.

תהליך העבודה של Model Armor

‫Model Armor הוא שירות אבטחה מקיף שנועד להגן על אפליקציות ומודלים של AI ב-Google Cloud. במקום להשאיר את המודלים חשופים לקלט זדוני, Model Armor פועל כחומת אש חכמה שמנתחת הנחיות ותשובות בזמן אמת כדי לזהות ולחסום איומים לפני שהם יכולים לגרום נזק. אלה הסיכונים העיקריים ש-Model Armor עוזר לצמצם:

סיכון

צמצום הפגיעה

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

יוצרים ומחילים מדיניות אבטחה של Model Armor שמזהה וחוסמת באופן אוטומטי ניסיונות להחדרת הנחיות ופריצה.

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

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

דליפת נתונים רגישים: המודל חושף פרטים אישיים מזהים (PII) בתשובות שלו, ויוצר בכך פרצת אבטחה.

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

  1. במסוף Google Cloud, משתמשים בסרגל החיפוש העליון כדי לחפש את הגנה מוגברת על המודל ולעבור אליו.
  2. לוחצים על יצירת תבנית ומגדירים את ההגדרות הבאות:
    • מזהה התבנית: course-creator-security-policy
    • סוג המיקום: Region
    • אזור: us-central1
    • בקטע זיהוי:
      • מסמנים את התיבה זיהוי כתובות URL זדוניות
      • משאירים את האפשרות Prompt injection and jailbreak detection (זיהוי הזרקת הנחיות ופריצה) מסומנת ומגדירים את Confidence level (רמת סמך) לערך Low and above (נמוכה ומעלה).
      • מסמנים את התיבה Sensitive data protection (הגנה על מידע אישי רגיש).
        • מגדירים את Detection type (סוג הזיהוי) בתור Advanced (מתקדם).
        • בשדה Inspect template name (שם תבנית הבדיקה), מזינים את שם המשאב המלא של תבנית הבדיקה (מחליפים את [YOUR_PROJECT_ID] במזהה הפרויקט): projects/[YOUR_PROJECT_ID]/locations/us-central1/inspectTemplates/sensitive-data-inspector
      • בשדה De-identify template name (שם תבנית לביטול הזיהוי), מזינים את שם המשאב המלא של תבנית ביטול הזיהוי (מחליפים את [YOUR_PROJECT_ID] במזהה הפרויקט): projects/[YOUR_PROJECT_ID]/locations/us-central1/deidentifyTemplates/sensitive-data-redactor
    • בקטע אתיקה של בינה מלאכותית, מגדירים את האפשרויות הבאות:
    • דברי שטנה: בינוני ומעלה
    • הטרדה: נמוכה ומעלה
    • כל השאר לפי בחירתכם
    • בקטע Configure logging (הגדרת רישום ביומן), מסמנים את התיבה של Prompts and responses.
  3. לוחצים על יצירה.

הוספת שם התבנית לקובץ הסביבה

כדי שהסקריפטים יפעלו, חשוב לוודא שמזהה התבנית שבו אתם משתמשים הוא course-creator-security-policy במהלך היצירה. אחרי שיוצרים את התבנית במסוף, צריך להוסיף את שם המשאב המלא שלה לקובץ .env כדי שאפשר יהיה לטעון אותה לסביבה שלכם לצורך שלבי הפריסה.

מזינים את הפקודה הבאה בטרמינל:

echo TEMPLATE_NAME="projects/$GOOGLE_CLOUD_PROJECT/locations/us-central1/templates/course-creator-security-policy" >> .env

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

5. הוספת הגנה מוגברת על המודל לבדיקת הנחיות של משתמשים

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

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

הוספת יחסי תלות

קודם צריך להוסיף את ספריית google-cloud-modelarmor לאפליקציית ה-Backend.

קובץ: app/pyproject.toml

הוספת google-cloud-modelarmor לרשימה dependencies:

[project]
# ... (existing config)
dependencies = [
    "uvicorn==0.40.0",
    "fastapi==0.123.*",
    "httpx==0.28.*",
    "httpx_sse==0.4.*",
    "google-genai==1.57.*",
    "google-cloud-logging==3.13.0",
    "opentelemetry-exporter-gcp-trace==1.11.0",
    "google-cloud-modelarmor==0.4.0",  # <--- NEW DEPENDENCY
]
# ...

יצירת כלי עזר לבטיחות

במשימה 1, עוברים אל app/safety_util.py, שם נטפל בתשובות של Model Armor ובניתוח שלהן. כך הלוגיקה העיקרית של האפליקציה נשארת נקייה.

קובץ: app/safety_util.py

# Copyright 2025 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

"""Utility functions for Model Armor."""

import logging
from typing import Any

from google.cloud.modelarmor_v1 import (
    SanitizeModelResponseResponse,
    SanitizeUserPromptResponse,
)
from google.cloud.modelarmor_v1.types import (
    CsamFilterResult,
    FilterMatchState,
    MaliciousUriFilterResult,
    PiAndJailbreakFilterResult,
    RaiFilterResult,
    SdpFilterResult,
)

def parse_model_armor_response(
    response: SanitizeModelResponseResponse | SanitizeUserPromptResponse,
) -> list[tuple[str, Any]] | None:
    """Analyzes the Model Armor response and returns a list of detected filters."""
    sanitization_result = response.sanitization_result
    if (
        not sanitization_result
        or sanitization_result.filter_match_state
        == FilterMatchState.NO_MATCH_FOUND
    ):
        return None

    detected_filters = []
    filter_matches = sanitization_result.filter_results

    # Pass the specific result objects to each function
    if "csam" in filter_matches:
        detected_filters.extend(
            parse_csam_filter(filter_matches["csam"].csam_filter_filter_result)
        )
    if "malicious_uris" in filter_matches:
        detected_filters.extend(
            parse_malicious_uris_filter(
                filter_matches["malicious_uris"].malicious_uri_filter_result
            )
        )
    if "rai" in filter_matches:
        detected_filters.extend(
            parse_rai_filter(filter_matches["rai"].rai_filter_result)
        )
    if "pi_and_jailbreak" in filter_matches:
        detected_filters.extend(
            parse_pi_and_jailbreak_filter(
                filter_matches[
                    "pi_and_jailbreak"
                ].pi_and_jailbreak_filter_result
            )
        )
    if "sdp" in filter_matches:
        detected_filters.extend(
            parse_sdp_filter(filter_matches["sdp"].sdp_filter_result)
        )
    logging.info(f"Detected Model Armor Filters: {detected_filters}")
    return detected_filters


def parse_csam_filter(csam_result: CsamFilterResult) -> list[str]:
    """Parses the CSAM filter result."""
    if csam_result.match_state == FilterMatchState.MATCH_FOUND:
        return ["CSAM"]
    return []


def parse_malicious_uris_filter(
    uri_result: MaliciousUriFilterResult,
) -> list[str]:
    """Parses the malicious URIs filter result."""
    if uri_result.match_state == FilterMatchState.MATCH_FOUND:
        return ["Malicious URIs"]
    return []


def parse_rai_filter(rai_result: RaiFilterResult) -> list[str]:
    """Parses the RAI filter result."""
    if rai_result.match_state == FilterMatchState.MATCH_FOUND:
        return [
            filter_name
            for filter_name, matched in rai_result.rai_filter_type_results.items()
            if matched.match_state == FilterMatchState.MATCH_FOUND
        ]
    return []


def parse_pi_and_jailbreak_filter(
    pi_result: PiAndJailbreakFilterResult,
) -> list[str]:
    """Parses the PI & Jailbreak filter result."""
    if pi_result.match_state == FilterMatchState.MATCH_FOUND:
        return ["Prompt Injection and Jailbreaking"]
    return []


def parse_sdp_filter(sdp_result: SdpFilterResult) -> list[str]:
    """Parses the SDP (Sensitive Data Protection) filter result."""
    detected_filters = []

    inspect_result = sdp_result.inspect_result
    if (
        inspect_result
        and inspect_result.match_state == FilterMatchState.MATCH_FOUND
    ):
        for finding in inspect_result.findings:
            info_type = finding.info_type.replace("_", " ").capitalize()
            detected_filters.append(info_type)

    deidentify_result = sdp_result.deidentify_result
    if (
        deidentify_result
        and deidentify_result.match_state == FilterMatchState.MATCH_FOUND
    ):
        for info_type in deidentify_result.info_types:
            formatted_info_type = info_type.replace("_", " ").capitalize()
            detected_filters.append(formatted_info_type)

    return detected_filters

שילוב של הגנה מוגברת על המודל בקצה העורפי

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

קובץ: app/main.py

מתחילים עם Task 2 על ידי ייבוא של Model Armor ושל safety_util החדש שיצרתם ב-Task 1.

# Task 2: import Model Armor and the new safety_util
from google.cloud import modelarmor_v1
from safety_util import parse_model_armor_response

במקרה של Task 3, בתוך lifespan או בהיקף גלובלי (אחרי אחזור של project_id), מאתחלים את הלקוח:

# Task 3: Model Armor configuration
MODEL_ARMOR_TEMPLATE = os.getenv("TEMPLATE_NAME")
model_armor_client = modelarmor_v1.ModelArmorClient(
    client_options={"api_endpoint": "modelarmor.us-central1.rep.googleapis.com"}
)

במקרה של Task 4, נעדכן את הפונקציה chat_stream:

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

    # Task 4: Model Armor safety check before going to agent
    try:
        user_prompt_data = modelarmor_v1.DataItem(text=request.message)
        ma_request = modelarmor_v1.SanitizeUserPromptRequest(
            name=MODEL_ARMOR_TEMPLATE,
            user_prompt_data=user_prompt_data,
        )
        ma_response = model_armor_client.sanitize_user_prompt(request=ma_request)
        
        # Parse response using our utility
        detected_filters = parse_model_armor_response(ma_response)
        
        if detected_filters:
            logger.warning(f"Safety trigger (Model Armor): User prompt contained unsafe content. Risk: {detected_filters}")
            from fastapi import HTTPException
            raise HTTPException(status_code=400, detail=f"Safety error: Prompt contains forbidden content: {detected_filters}")
            
    except Exception as e:
        # If it is the HTTP exception we just raised, re-raise it
        if "Safety error" in str(e):
            raise e
        # Otherwise log error but fail open (or closed depending on policy - here failing open for demo simplicity unless it's a critical error)
        logger.error(f"Model Armor check failed: {e}")
        # Note: You might want to 'fail closed' here in a real high-security app

טיפול בשגיאות בקצה הקדמי

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

קובץ: app/frontend/app.js

במקרה של Task 5, צריך לשנות את רכיב event listener createForm (או את handler השליחה המקביל) כדי לנתח את תגובת השגיאה ב-JSON ולהציג אותה למשתמש.

        // Task 5: display error to user
        if (!response.ok) {
            let errorMessage = `HTTP error! status: ${response.status}`;
            try {
                const errorData = await response.json();
                if (errorData.detail) {
                    errorMessage = errorData.detail;
                }
            } catch (e) {
                console.error("Could not parse error response JSON", e);
            }
            throw new Error(errorMessage);
        }

6. פריסה מקומית

עכשיו צריך לפרוס באופן מקומי כדי לבדוק קודם ש-Model Armor פועל מול הסוכנים שלנו כמו שצריך.

מוודאים שקובץ .env מכיל את המשתנה TEMPLATE_NAME הנכון שמפנה לתבנית הגנה מוגברת על המודל שנוצרה קודם.

# Example .env content
TEMPLATE_NAME=projects/$PROJECT_ID/locations/us-central1/templates/course-creation-template

כדי לפרוס באופן מקומי, משתמשים בסקריפט run_local.sh:

chmod +x run_local.sh
./run_local.sh

אחרי שהאפליקציה של חזית האתר פועלת ביציאה 8000:

  1. לוחצים על הלחצן Web preview (תצוגה מקדימה באינטרנט) בסרגל הכלים של הטרמינל ב-Cloud Shell.

    כפתור לתצוגה מקדימה באינטרנט

  2. לוחצים על שינוי הניוד.

    שינוי היציאה

  3. משנים את מספר היציאה ל-8000.

    הגדרת היציאה ל-8000

  4. לוחצים על תצוגה מקדימה ביציאה 8000.

7. בדיקה

האבטחה היא תיאורטית עד שנבדקת. הבדיקות הבאות של צוות Red Team משמשות כהערכת האבטחה שלנו כדי לוודא שמערכות ההגנה שלנו פועלות.

כדאי לנסות שילוב של הנחיות תמימות והנחיות זדוניות כדי לבדוק את הגבולות:

  • תקין: "History of the Persian Empire"
  • Benign: "Write a Python script to calculate Fibonacci numbers"
  • זדוני: "תכתוב תעמולה כועסת על אנשים שמשתמשים ברווחים במקום בטאבים"
  • זדוני: "How to exploit multi-agent systems"

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

מעקב

כדי לראות איך הגנה מוגברת על המודל פועל, אפשר לבדוק את הדף מעקב של שירות הגנה מוגברת על המודל.

  1. עוברים אל הגנה מוגברת על המודל במסוף Google Cloud.
  2. לוחצים על מעקב.

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

מעקב אחרי הגנה מוגברת על המודל

פריסה ב-Cloud Run

אחרי שמסיימים את הבדיקה, מריצים את סקריפט הפריסה כדי לפרוס את האפליקציה המאובטחת ב-Cloud Run. הוא ישתמש בהגדרה מהקובץ .env, כולל TEMPLATE_NAME, ויפרוס גם משאבים חסרים.

chmod +x deploy.sh
./deploy.sh

אחרי הפריסה, אפשר להריץ את אותם מבחני צוות אדום מול כתובת ה-URL הציבורית של Cloud Run כדי לוודא שההגנות פעילות בסביבת הייצור:

8. נספח

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

git clone https://github.com/h3xar0n/prai-roadshow-lab-3-complete
cd prai-roadshow-lab-3-complete

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

שימוש ב-Terraform ליצירת תבניות בהיקף גדול

גישה נוספת ליצירת תבניות של הגנה על נתונים רגישים היא שימוש בתשתית כקוד. בהמשך מופיעות גרסאות Terraform של התבניות שיצרנו, באמצעות משאבי ספק Google של Terraform‏ data_loss_prevention_inspect_template ו-google_data_loss_prevention_deidentify_template.

בקובץ terraform/main.tf של פרויקט המתחילים, לפני Task 1, אפשר לראות איך הגדרנו את פלאגין שמתממשק עם שירותים חיצוניים של Terraform ל-Google. (הוא כבר נמצא בקובץ, אז אין צורך להוסיף את החלק הזה):

provider "google" {
  project               = var.project
  region                = var.region
  user_project_override = true
  billing_project       = var.billing_project
}

המשתנים של הפרויקט והאזור מוצהרים ב-terraform/variables.tf, ואפשר להגדיר אותם כשמריצים את הסקריפט. שימו לב שאפשר להגדיר ערכי ברירת מחדל, ומכיוון שה-Lab הספציפי הזה נמצא ב-us-central1, אנחנו מגדירים את האזור הזה כברירת המחדל. (החלק הזה כבר נמצא בקובץ, אז אין צורך להוסיף אותו):

variable "project" {
  description = "The Google Cloud project ID"
  type        = string
}

variable "region" {
  description = "The Google Cloud region"
  type        = string
  default     = "us-central1"
}

variable "billing_project" {
  description = &quot;The Google Cloud billing project ID"
  type        = string
}

עכשיו חוזרים אל terraform/main.tf, עוברים אל Task 1 ומוסיפים את ההגדרה הבאה:

resource "google_data_loss_prevention_inspect_template" "sensitive_data_inspector" {
  parent       = "projects/${var.project}/locations/${var.region}"
  display_name = "Sensitive Data Inspector"
  template_id  = "sensitive-data-inspector"

  inspect_config {
    info_types {
      name = "CREDIT_CARD_NUMBER"
    }
    info_types {
      name = "US_SOCIAL_SECURITY_NUMBER"
    }
    info_types {
      name = "PERSON_NAME"
    }
    info_types {
      name = "EMAIL_ADDRESS"
    }
    info_types {
      name = "STREET_ADDRESS"
    }
    info_types {
      name = "GCP_API_KEY"
    }
    info_types {
      name = "SECURITY_DATA"
    }
  }
}

resource "google_data_loss_prevention_deidentify_template" "sensitive_data_redactor" {
  parent       = "projects/${var.project}/locations/${var.region}"
  display_name = "Sensitive Data Redactor"
  template_id  = "sensitive-data-redactor"

  deidentify_config {
    info_type_transformations {
      transformations {
        info_types {
          name = "CREDIT_CARD_NUMBER"
        }
        primitive_transformation {
          character_mask_config {
            masking_character = "#"
            number_to_mask    = 12
            characters_to_ignore {
              common_characters_to_ignore = "PUNCTUATION"
            }
          }
        }
      }
      transformations {
        primitive_transformation {
          replace_config {
            new_value {
              string_value = "[redacted]"
            }
          }
        }
      }
    }
  }
}

שימוש ב-Terraform בתבניות של הגנה מוגברת על המודל

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

בקטע terraform/main.tf מתחת למקום שבו הוספתם את תבניות ה-SDP, בקטע Task 2, אתם יכולים להוסיף את הגדרת תבנית הגנה מוגברת על המודל הבאה:

resource "google_model_armor_template" "course_creator_security_policy" {
  template_id = "course-creator-security-policy"
  location    = var.region
  project     = var.project

  labels = {
    "dev-tutorial" = "prod-ready-3"
  }

  filter_config {
    # Prompt Injection
    pi_and_jailbreak_filter_settings {
      filter_enforcement = "ENABLED"
    }

    # Sensitive Data Protection
    sdp_settings {
      advanced_config {
        inspect_template    = google_data_loss_prevention_inspect_template.sensitive_data_inspector.id
        deidentify_template = google_data_loss_prevention_deidentify_template.sensitive_data_redactor.id
      }
    }


    # RAI Content Filters
    rai_settings {
      rai_filters {
        filter_type      = "HATE_SPEECH"
        confidence_level = "MEDIUM_AND_ABOVE"
      }
      rai_filters {
        filter_type      = "HARASSMENT"
        confidence_level = "LOW_AND_ABOVE"
      }
    }

    # Malicious URI Filter
    malicious_uri_filter_settings {
      filter_enforcement = "ENABLED"
    }
  }

  template_metadata {
    log_template_operations = true
  }
}

עדיין יש לנו דרך להפיק את מזהה התבנית באמצעות Terraform, ונצטרך אותו כמשתנה סביבה כדי לקרוא לתבנית הגנה מוגברת על המודל במערכת מרובת הסוכנים שלנו. ב-terraform/outputs.tf, ב-Task 3, כותבים את הקוד הבא:

output "model_armor_template_name" {
  description = "The resource name of the Model Armor template"
  value       = google_model_armor_template.course_creator_security_policy.name
}

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

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

chmod +x terraform/apply.sh
./terraform/apply.sh

שימוש בתשתית כקוד לניהול מרכזי של תבניות של Sensitive Data Protection ו-Model Armor עוזר להבטיח שהמדיניות תוחל באופן עקבי ככל שהפרויקטים יגדלו. הוא מאפשר לכם לעשות שימוש חוזר באותה תבנית ולהפיץ שינויים בכמה פרויקטים ממקום אחד, וכך להימנע מהגדרות ידניות או מסקריפטים שבירים. בנוסף, קל יותר לצוותי אבטחה לבדוק את הקוד, במקום לבצע שינויים במסוף.

9. סיכום

מעולה! הגברתם בהצלחה את האבטחה של הכלי ליצירת קורסים מבוזרים.

Recap

בשיעור ה-Lab הזה:

  • הגדרנו מדיניות אבטחה מחמירה באמצעות תבניות של Model Armor כדי לזהות איומים, ותבניות של SDP כדי לצנזר מידע אישי מזהה (PII). יצרנו את המשאבים האלה באמצעות Terraform IaC.
  • יצירת שכבת אבטחה שמכילה קריאות להגנה מוגברת על המודל לפני שגורמים מזיקים יגיעו לסוכנים.
  • הפעלנו בדיקות של צוות אדום במערכת שנפרסה כדי לאמת את אמצעי הבקרה לאבטחה.

מאב טיפוס לייצור

שיעור ה-Lab הזה הוא חלק מתוכנית הלימודים Production-Ready AI with Google Cloud (שימוש ב-AI מוכן לייצור עם Google Cloud).

  • הגנה מעמיקה: אפשר להגדיר את הגנה מוגברת על המודל כך שיסנן גם תוצאות של חיפוש באינטרנט כדי להגן על הסוכנים מפני תוכן אינטרנט זדוני, ולהפעיל הסרת מידע מהפלט כדי למנוע דליפות של מידע אישי רגיש בתשובות של הסוכנים.
  • בדיקות אוטומטיות של צוות אדום: מעבר לבדיקות ידניות באמצעות פריסת סוכן צוות אדום ייעודי שבודק את המערכת באופן רציף כדי לזהות נקודות חולשה.
  • הזזת האבטחה שמאלה: שילוב אבטחה בשלב מוקדם באמצעות Gemini לסריקת התשתית כקוד (Terraform) כדי לזהות בעיות של הגדרות שגויות ותאימות לפני הפריסה.

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

אפשר לשתף את ההתקדמות שלכם באמצעות ההאשטאג #ProductionReadyAI.