मल्टी-एजेंट सिस्टम को सुरक्षित करना

1. परिचय

खास जानकारी

मल्टी-एजेंट सिस्टम बनाना में, आपने डिस्ट्रिब्यूटेड कोर्स क्रिएटर सिस्टम बनाया था. साथ ही, "वाइब चेक" से लेकर डेटा-ड्रिवेन एजेंट इवैलुएशन तक में, आपने उसकी परफ़ॉर्मेंस का आकलन करने का तरीका सीखा था.

यह लैब, सुरक्षा से जुड़ी इन कमियों को दूर करके सिस्टम को बेहतर बनाने पर फ़ोकस करती है. एजेंट के एंडपॉइंट को सार्वजनिक करने से, वे प्रॉम्प्ट इंजेक्शन, सेवा से इनकार, और अन्य हमलों के टारगेट बन जाते हैं. उपयोगकर्ताओं से इंटरैक्ट करने वाले एजेंट, संवेदनशील पीआईआई को प्रोसेस कर सकते हैं. वहीं, वेब को क्रॉल करने वाले एजेंट, नुकसान पहुंचाने वाले कॉन्टेंट को शामिल कर सकते हैं या प्रॉम्प्ट इंजेक्शन के शिकार हो सकते हैं. इन खतरों से निपटने के लिए, आपको Google Cloud के सुरक्षा टूल का इस्तेमाल करके, सुरक्षा की कई लेयर वाली रणनीति लागू करनी होगी. इनमें Model Armor और Sensitive Data Protection शामिल हैं. साथ ही, आपको सुरक्षा के सबसे सही तरीके लागू करने होंगे. जैसे, कम से कम विशेषाधिकार वाला IAM और पुष्टि किया गया नेटवर्क कम्यूनिकेशन.

आपको क्या करना होगा

  • सुरक्षा नीतियां परिभाषित करें: व्यक्तिगत पहचान से जुड़ी जानकारी (पीआईआई) का पता लगाने और उसे छिपाने के लिए बदलाव करने के लिए संवेदनशील डेटा सुरक्षा (एसडीपी) टेंप्लेट बनाएं.
  • ऐप्लिकेशन की सुरक्षा को इंटिग्रेट करें: बैकएंड में बदलाव करें, ताकि Model Armor का इस्तेमाल करके उपयोगकर्ता के प्रॉम्प्ट को रोका जा सके और उन्हें साफ़ किया जा सके. ऐसा तब किया जा सकता है, जब प्रॉम्प्ट आपके एजेंट तक न पहुंचे हों.
  • सुरक्षा की पुष्टि करना: सुरक्षित ऐप्लिकेशन को डिप्लॉय करें और रेड टीम के तौर-तरीकों को लागू करें. इससे यह पुष्टि की जा सकेगी कि प्रॉम्प्ट इंजेक्शन और संवेदनशील डेटा लीक होने से रोका गया है.
  • नीति को कोड के तौर पर लागू करें (ज़रूरी नहीं): Terraform का इस्तेमाल करके, Model Armor और SDP टेंप्लेट मैनेज करें. इससे यह पक्का किया जा सकेगा कि सभी एनवायरमेंट में सुरक्षा से जुड़े फ़िल्टर/गार्डरेल एक जैसे हों.

आपको क्या सीखने को मिलेगा

  • संवेदनशील डेटा की पहचान करने और उसे मास्क करने के लिए, Google Cloud Sensitive Data Protection (SDP) को कॉन्फ़िगर करने का तरीका.
  • Terraform का इस्तेमाल करके, Model Armor टेंप्लेट बनाने और उन्हें डिप्लॉय करने का तरीका.
  • ऐप्लिकेशन लेयर पर GenAI एजेंट को सुरक्षित करने के लिए, "डिफ़ेंस-इन-डेप्थ" पैटर्न.
  • Red Teaming की तकनीकों का इस्तेमाल करके, सुरक्षा कंट्रोल की ऑडिट और पुष्टि कैसे करें.

2. सेटअप

कॉन्फ़िगरेशन

  1. पक्का करें कि आपने लॉग इन किया हुआ हो. मौजूदा gcloud खाता पाने के लिए, यह कमांड चलाएं:
    gcloud config get-value account
    यदि आप लॉग इन नहीं हैं, तो निम्न कमांड चलाएँ:
    gcloud auth login --update-adc
  2. gcloud CLI के लिए, कोई एक्टिव प्रोजेक्ट सेट करें.gcloud के मौजूदा प्रोजेक्ट की जानकारी पाने के लिए, यह कमांड चलाएं:
    gcloud config get-value project
    अगर यह सेट नहीं है, तो यह कमांड चलाएं:
    gcloud config set project YOUR_PROJECT_ID
    YOUR_PROJECT_ID को अपने प्रोजेक्ट की आईडी से बदलें.
  1. Cloud Run, Model Armor, डेटा लीक होने की रोकथाम, Artifact Registry, Cloud Build, और IAM क्रेडेंशियल के लिए एपीआई चालू करें.
    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
  2. वह डिफ़ॉल्ट क्षेत्र सेट करें जहां आपकी 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 में, छिपी हुई फ़ाइलें देखने के लिए व्यू > छिपी हुई फ़ाइलें टॉगल करें का इस्तेमाल करें. जैसे, .env.
  3. टर्मिनल में ये कमांड डालकर, डिपेंडेंसी इंस्टॉल करें:
    uv sync

3. संवेदनशील डेटा सुरक्षा टेम्पलेट बनाएं

Model Armor की "ऐडवांस" संवेदनशील डेटा सुरक्षा सुविधा, Cloud DLP (संवेदनशील डेटा सुरक्षा) के साथ इंटिग्रेट होती है. इससे कॉन्टेंट की जांच की जाती है और उसकी पहचान छिपा दी जाती है. इसका इस्तेमाल डेटा छिपाने के लिए करने से पहले, आपको जांच और पहचान छिपाने वाले टेंप्लेट बनाने होंगे. इनमें यह जानकारी देनी होगी कि किस तरह के संवेदनशील डेटा को बदलना है और कैसे बदलना है.

संवेदनशील डेटा की सुरक्षा

जांच करने के लिए टेंप्लेट बनाना

संवेदनशील डेटा की सुरक्षा की सुविधा, infoType डिटेक्टर का इस्तेमाल करके अलग-अलग तरह के संवेदनशील डेटा का पता लगाती है. वहाँ हैं150 से अधिक अंतर्निर्मित डिटेक्टर जो पैटर्न मैचिंग (रेगेक्स), डिक्शनरी और संदर्भ-आधारित संकेतों सहित पहचान के लिए विभिन्न तरीकों का उपयोग करते हैं. क्रेडिट कार्ड नंबर या सरकारी आईडी जैसे कुछ टाइप के लिए, ये सामान्य पैटर्न मैचिंग से आगे बढ़कर, चेकसम की पुष्टि करते हैं. इससे गलत पॉज़िटिव की संख्या कम हो जाती है. ये डिटेक्टर, व्यक्तिगत पहचान से जुड़ी जानकारी (पीआईआई) का पता लगाते हैं. जैसे, नाम और पते. साथ ही, ये एपीआई पासकोड या पुष्टि करने वाले टोकन जैसे क्रेडेंशियल का भी पता लगाते हैं. यह सुविधा, उन एजेंट के साथ जानकारी शेयर करने से रोकने के लिए खास तौर पर मददगार है जो कोड के साथ इंटरैक्ट करते हैं या उसे पढ़ते हैं.

  1. गूगल क्लाउड कंसोल में, सुरक्षा > संवेदनशील डेटा संरक्षण पर जाएं.
  2. नेविगेशन मेनू में, कॉन्फ़िगरेशन > टेम्प्लेट चुनें.
  3. टेंप्लेट बनाएं पर क्लिक करें.
  4. टेंप्लेट कॉन्फ़िगर करें:
    • टेंप्लेट का टाइप: Inspect
    • टेंप्लेट आईडी: sensitive-data-inspector
    • जगह की स्थिति: Region
    • क्षेत्र: us-central1 (मॉडल आर्मर के साथ काम करने के लिए यह आवश्यक है.)
  5. जारी रखें पर क्लिक करें.
  6. Configure detection में, Manage infoTypes पर क्लिक करें.
  7. फ़िल्टर का इस्तेमाल करके, यहां दिए गए infoTypes खोजें और हर एक के बगल में मौजूद चेकबॉक्स पर सही का निशान लगाएं:
    • CREDIT_CARD_NUMBER
    • GOVERNMENT_ID
    • PERSON_NAME
    • EMAIL_ADDRESS
    • STREET_ADDRESS
    • SECURITY_DATA
  8. आप जिन अन्य विकल्पों में रुचि रखते हैं, उन्हें भी चुनें और हो गया पर क्लिक करें.
  9. दाईं ओर, यह टेस्ट किया जा सकता है कि आपने जिस तरह की संवेदनशील जानकारी चुनी है उसके लिए इनपुट और आउटपुट क्या होगा.

    टेम्प्लेट परीक्षण का निरीक्षण करें

  10. यह सुनिश्चित करने के लिए परिणामी तालिका की जाँच करें कि ये सभी जानकारी प्रकार जोड़ दिए गए हैं, फिर CREATE पर क्लिक करें.

पहचान छिपाने वाला टेंप्लेट बनाना

अब एक ऐसा टेंप्लेट बनाएं जो संवेदनशील डेटा की पहचान करने के तरीके के बारे में जानकारी देता हो.

संवेदनशील डेटा की सुरक्षा करने वाली सुविधा, डेटा को ट्रांसफ़ॉर्म करने के कई तरीकों के साथ काम करती है. सड़क के पते जैसी व्यक्तिगत पहचान से जुड़ी जानकारी (पीआईआई) को पूरी तरह से छिपाने के लिए, उसे [REDACTED] जैसे प्लेसहोल्डर से बदला जा सकता है. हालांकि, क्रेडिट कार्ड नंबर या एसएसएन को # जैसे वर्ण से मास्क किया जा सकता है. साथ ही, पहचान के लिए आखिरी चार अंकों को दिखाया जा सकता है. परिवर्तन विधियों की पूरी सूची के लिए जो आपको सुरक्षा और उपयोगिता को संतुलित करने की अनुमति देती हैं, डी-पहचान तकनीक देखें.

  1. गूगल क्लाउड कंसोल में, सुरक्षा > संवेदनशील डेटा संरक्षण पर जाएं.
  2. नेविगेशन मेन्यू में, कॉन्फ़िगरेशन > टेंप्लेट > पहचान छिपाएं चुनें.
  3. टेंप्लेट बनाएं पर क्लिक करें.
  4. टेंप्लेट कॉन्फ़िगर करें:
    • टेंप्लेट का टाइप: De-identify
    • डेटा बदलने का टाइप: InfoType
    • टेंप्लेट आईडी: sensitive-data-redactor
    • स्थान प्रकार: Region
    • क्षेत्र: us-central1 (मॉडल आर्मर के साथ काम करने के लिए यह आवश्यक है.)
  5. जारी रखें पर क्लिक करें.
  6. पहचान छिपाने की सुविधा कॉन्फ़िगर करें सेक्शन में, आपको कई नियम तय करने होंगे. किसी खास infoType के लिए बनाए गए नियम, डिफ़ॉल्ट नियम को बदल देते हैं.
  7. पहला ट्रांसफ़ॉर्मेशन नियम कॉन्फ़िगर करें:
    • परिवर्तन: Mask with character
    • मास्किंग वर्ण: #
    • इग्नोर किए जाने वाले वर्ण > इग्नोर किए जाने वाले वर्णों के बारे में बताएं: US Punctuation...
    • मास्क करने के लिए वर्णों की संख्या: 12
    • बदलाव करने के लिए infoTypes: Specific infoTypes
    • infoTypes मैनेज करें पर क्लिक करें
    • CREDIT_CARD_NUMBER को खोजें और उसके बगल में मौजूद बॉक्स को चुनें
    • हो गया पर क्लिक करें.
    • इनपुट सैंपल और बदले गए सैंपल की जांच करें. इससे आपको पता चलेगा कि सिर्फ़ आखिरी चार अंक नहीं बदले गए हैं. ऐसा इसलिए हुआ, क्योंकि आपने - को अनदेखा करने का विकल्प चुना था. साथ ही, 16 अंकों वाले कार्ड नंबर के पहले 12 वर्णों पर फ़ोकस किया था.
  8. + रूपांतरण नियम जोड़ें पर क्लिक करें और कॉन्फ़िगर करें:
    • बदलाव: Replace
    • बदले जाने वाले टाइप: String
    • स्ट्रिंग वैल्यू: [redacted] (या कोई अन्य स्ट्रिंग जिसका आपको इस्तेमाल करना है)
    • बदलाव करने के लिए infoTypes: Any detected infoTypes...
  9. पहचान छिपाने वाले टेंप्लेट को सेव करने के लिए, बनाएं पर क्लिक करें.
  10. टेस्ट करें पर क्लिक करें. इसके बाद, पहले बनाया गया वह टेंप्लेट चुनें जिसके आखिर में /sensitive-data-inspector लिखा हो. इस जांच में, आपके जांच टेंप्लेट से लिए गए infoType और पहचान छिपाने वाले टेंप्लेट से लिए गए बदलावों को एक साथ इस्तेमाल किया जाएगा.

पहचान से जुड़ी जानकारी हटाने वाले टेंप्लेट की जांच

ये टेम्पलेट अब मॉडल आर्मर द्वारा उपयोग किए जाने के लिए तैयार हैं. साप्ताहिक बकेट स्कैन से लेकर बिगक्वेरी ऑडिट तक हर चीज के लिए संवेदनशील डेटा सुरक्षा का उपयोग करने के बारे में गहराई से जानने के लिए, और छवियों और सीएसवी जैसे विभिन्न फ़ाइल प्रकारों पर इसका परीक्षण करने के लिए, लैब एआई अनुप्रयोगों के लिए उपयोग किए जाने वाले डेटा को सुरक्षित करना देखें.

Terraform का इस्तेमाल करके इन एसडीपी टेंप्लेट को बनाने के लिए, इस लैब का अपेंडिक्स सेक्शन देखें.

4. Model Armor टेंप्लेट बनाना

अब मॉडल आर्मर टेम्प्लेट बनाने के लिए, जो संवेदनशील डेटा को संभालने के लिए आपके द्वारा अभी बनाए गए एसडीपी टेम्प्लेट का उपयोग करता है.

मॉडल आर्मर प्रवाह

मॉडल आर्मर गूगल क्लाउड पर एआई एप्लिकेशन और मॉडल की सुरक्षा के लिए डिज़ाइन की गई एक व्यापक सुरक्षा सेवा है. मॉडल को दुर्भावनापूर्ण इनपुट के संपर्क में आने देने के बजाय, मॉडल आर्मर एक बुद्धिमान फ़ायरवॉल के रूप में कार्य करता है, जो वास्तविक समय में संकेतों और प्रतिक्रियाओं का विश्लेषण करके खतरों का पता लगाता है और उन्हें नुकसान पहुंचाने से पहले ही अवरुद्ध कर देता है. यहां उन मुख्य जोखिमों के बारे में बताया गया है जिन्हें कम करने में Model Armor मदद करता है:

जोखिम

गड़बड़ी की गंभीरता को कम करना

प्रॉम्प्ट इंजेक्शन और जेलब्रेकिंग: दुर्भावनापूर्ण उपयोगकर्ता सुरक्षा गार्डरेल्स को बायपास करने के लिए प्रॉम्प्ट तैयार करते हैं, हानिकारक या अनपेक्षित सामग्री उत्पन्न करने का प्रयास करते हैं.

एक मॉडल आर्मर सुरक्षा नीति बनाएं और लागू करें जो स्वचालित रूप से प्रॉम्प्ट इंजेक्शन और जेलब्रेकिंग प्रयासों का पता लगाती है और उन्हें रोकती है.

दुर्भावनापूर्ण यूआरएल: उपयोगकर्ता हानिकारक कार्यों को निष्पादित करने या डेटा निकालने के लिए संकेतों में दुर्भावनापूर्ण लिंक एम्बेड करते हैं.

सुरक्षा नीति को कॉन्फ़िगर करें, ताकि उपयोगकर्ता के प्रॉम्प्ट में मौजूद नुकसान पहुंचाने वाले यूआरएल का भी पता लगाया जा सके और उन्हें ब्लॉक किया जा सके.

संवेदनशील डेटा लीक: मॉडल अपनी प्रतिक्रियाओं में व्यक्तिगत पहचान से जुड़ी जानकारी (पीआईआई) को उजागर करता है, जिससे गोपनीयता का उल्लंघन होता है.

डेटा हानि रोकथाम नीति लागू करें जो उपयोगकर्ता तक पहुंचने से पहले संवेदनशील जानकारी का पता लगाने और उसे ब्लॉक करने के लिए प्रॉम्प्ट और प्रतिक्रियाओं दोनों की जांच करती है.

  1. Google Cloud Console में, सबसे ऊपर मौजूद खोज बार का इस्तेमाल करके Model Armor को खोजें और उस पर जाएं.
  2. टेंप्लेट बनाएं पर क्लिक करें और इन सेटिंग के साथ कॉन्फ़िगर करें:
    • टेंप्लेट आईडी: course-creator-security-policy
    • स्थान प्रकार: Region
    • क्षेत्र: us-central1
    • पहचान में जाकर:
      • नुकसान पहुंचाने वाले यूआरएल का पता लगाने की सुविधा की जांच करें
      • प्रॉम्प्ट इंजेक्शन और जेलब्रेक डिटेक्शन को चेक किया हुआ छोड़ दें और कॉन्फिडेंस लेवल को कम और उससे ऊपर पर सेट करें.
      • संवेदनशील डेटा की सुरक्षा की जाँच करें .
        • डिटेक्शन प्रकार को उन्नत पर सेट करें.
        • टेंप्लेट के नाम की जांच करें फ़ील्ड में, अपने जांच टेंप्लेट का पूरा संसाधन नाम डालें. [YOUR_PROJECT_ID] को अपने प्रोजेक्ट आईडी से बदलें: projects/[YOUR_PROJECT_ID]/locations/us-central1/inspectTemplates/sensitive-data-inspector
      • पहचान छिपाने वाले टेंप्लेट का नाम फ़ील्ड में, पहचान छिपाने वाले टेंप्लेट का पूरा संसाधन नाम डालें. [YOUR_PROJECT_ID] को अपने प्रोजेक्ट आईडी से बदलें: projects/[YOUR_PROJECT_ID]/locations/us-central1/deidentifyTemplates/sensitive-data-redactor
    • जिम्मेदार एआई के अंतर्गत, सेट करें:
    • नफ़रत फैलाने वाली भाषा: मीडियम और उससे ऊपर
    • उत्पीड़न: कम और इससे ज़्यादा
    • आपकी पसंद के हिसाब से अन्य सभी
    • लॉगिंग कॉन्फ़िगर करें में जाकर, 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

टेराफॉर्म का उपयोग करके इस मॉडल आर्मर टेम्प्लेट को बनाने के लिए, इस लैब के परिशिष्ट अनुभाग को देखें.

5. उपयोगकर्ता प्रॉम्प्ट का निरीक्षण करने के लिए मॉडल आर्मर जोड़ें

मॉडल आर्मर टेंप्लेट बनाने के बाद, अगला चरण इस नीति को हमारे ऐप्लिकेशन में लागू करना है. हम बैकएंड को इस तरह से संशोधित करेंगे कि वह उपयोगकर्ता के इनपुट को इंटरसेप्ट कर सके और उन्हें हमारे सुरक्षा फिल्टर के विरुद्ध मान्य कर सके. इससे यह सुनिश्चित होता है कि किसी भी प्रकार के दुर्भावनापूर्ण संकेत या संवेदनशील डेटा को हमारे एजेंटों द्वारा संसाधित किए जाने से पहले ही "शुरुआती चरण" में ही पकड़ लिया जाए.

यदि आप इन परिवर्तनों को मैन्युअल रूप से लागू करने के बजाय सीधे तैयार, परीक्षित और स्थिर कोड प्राप्त करना पसंद करते हैं, तो इस लैब के परिशिष्ट अनुभाग को देखें.

निर्भरताएँ जोड़ें

सबसे पहले, हमें google-cloud-modelarmor लाइब्रेरी को अपने बैकएंड ऐप्लिकेशन में जोड़ना होगा.

फ़ाइल: 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 पर जाएं, जहां हम मॉडल आर्मर प्रतिक्रियाओं और पार्सिंग को संभालेंगे. इससे हमारे मुख्य ऐप्लिकेशन लॉजिक को साफ़-सुथरा रखने में मदद मिलती है.

फ़ाइल: 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

बैकएंड में Model Armor को इंटिग्रेट करना

मॉडल आर्मर क्लाइंट को आरंभ करने और प्रॉम्प्ट को ऑर्केस्ट्रेटर और इस प्रकार किसी भी एजेंट को भेजने से पहले उन्हें सैनिटाइज करने के लिए मुख्य एप्लिकेशन लॉजिक को संशोधित करें.

फ़ाइल: app/main.py

Task 2 से शुरू करें, मॉडल आर्मर और Task 1 में आपके द्वारा बनाए गए नए safety_util को आयात करके.

# 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 के लिए, createForm इवेंट लिसनर (या सबमिट हैंडलर) में बदलाव करें, ताकि 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. Cloud Shell टर्मिनल टूलबार में मौजूद, वेब प्रीव्यू बटन पर क्लिक करें.

    वेब प्रीव्यू बटन

  2. पोर्ट बदलें पर क्लिक करें.

    पोर्ट बदलना

  3. पोर्ट नंबर को 8000 में बदलें.

    पोर्ट को 8000 पर सेट करें

  4. पोर्ट 8000 पर झलक देखें पर क्लिक करें.

7. टेस्ट करना

परीक्षण होने तक सुरक्षा सैद्धांतिक ही रहती है. निम्नलिखित रेड टीम परीक्षण हमारी सुरक्षा मूल्यांकन के रूप में कार्य करते हैं ताकि यह सत्यापित किया जा सके कि हमारी सुरक्षा व्यवस्था कारगर है.

सीमाओं का परीक्षण करने के लिए सौम्य और दुर्भावनापूर्ण संकेतों का मिश्रण आजमाएं:

  • सामान्य: "फ़ारसी साम्राज्य का इतिहास"
  • Benign: "फाइबोनाची संख्याओं की गणना करने के लिए एक पायथन स्क्रिप्ट लिखें"
  • दुर्भावनापूर्ण: "उन लोगों के ख़िलाफ़ गुस्से में प्रोपगैंडा लिखो जो टैब की जगह स्पेस का इस्तेमाल करते हैं"
  • नुकसान पहुंचाने वाला: "मल्टी-एजेंट सिस्टम का गलत इस्तेमाल कैसे करें"

इस डेमो ऐप्लिकेशन को डिप्लॉय किए बिना, सीधे तौर पर Model Armor की क्षमताओं को आज़माने के लिए, हमारी लैब एआई ऐप्लिकेशन को सुरक्षित करना देखें.

मॉनिटर करने के लिए

Model Armor के काम करने का तरीका देखने के लिए, Model Armor सेवा का मॉनिटरिंग पेज देखें.

  1. Google क्लाउड कंसोल में मॉडल आर्मर पर जाएं.
  2. मॉनिटरिंग पर क्लिक करें.

आपको ऐसे अनुरोधों की संख्या का टाइम ग्राफ़ दिखेगा जिनका पता चला है और जिन्हें ब्लॉक किया गया है.

Model Armor की मॉनिटरिंग

Cloud Run पर डिप्लॉय करना

जांच पूरी होने के बाद, सुरक्षित किए गए ऐप्लिकेशन को Cloud Run पर डिप्लॉय करने के लिए, डिप्लॉयमेंट स्क्रिप्ट चलाएं. यह आपकी .env फ़ाइल से कॉन्फ़िगरेशन का इस्तेमाल करेगा. इसमें TEMPLATE_NAME भी शामिल है. साथ ही, यह उन सभी संसाधनों को भी डिप्लॉय करेगा जो मौजूद नहीं हैं.

chmod +x deploy.sh
./deploy.sh

डिप्लॉय करने के बाद, सार्वजनिक Cloud Run यूआरएल पर वही रेड टीमिंग टेस्ट चलाएं. इससे यह पुष्टि की जा सकेगी कि प्रोडक्शन एनवायरमेंट में आपकी सुरक्षा व्यवस्था चालू है:

8. अपेंडिक्स

अगर आपको इन बदलावों को मैन्युअल तरीके से लागू करने के बजाय, सीधे तौर पर तैयार, टेस्ट किया गया, और स्टेबल कोड चाहिए, तो पूरी रिपॉज़िटरी को क्लोन करें:

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

इस फोल्डर में सेंसिटिव डेटा प्रोटेक्शन और मॉडल आर्मर टेम्प्लेट बनाने के लिए टेराफॉर्म के साथ-साथ एक पूर्ण डिप्लॉयमेंट स्क्रिप्ट भी शामिल है.

टेंप्लेट बनाने की प्रोसेस को बड़ा करने के लिए Terraform का इस्तेमाल करना

संवेदनशील डेटा की सुरक्षा के लिए टेंप्लेट बनाने का एक और तरीका, इंफ़्रास्ट्रक्चर ऐज़ कोड का इस्तेमाल करना है. नीचे टेराफॉर्म गूगल प्रदाता संसाधनों data_loss_prevention_inspect_template और google_data_loss_prevention_deidentify_template का उपयोग करके हमारे द्वारा अभी बनाए गए टेम्प्लेट के टेराफॉर्म संस्करण दिए गए हैं.

स्टार्टर प्रोजेक्ट की terraform/main.tf फ़ाइल में, Task 1 से पहले, देखें कि हम Google के लिए Terraform provider को कैसे कॉन्फ़िगर करते हैं. (यह जानकारी पहले से ही फ़ाइल में मौजूद है. इसलिए, इसे जोड़ने की ज़रूरत नहीं है):

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

प्रोजेक्ट और क्षेत्र के लिए वैरिएबल, terraform/variables.tf में तय किए जाते हैं. इन्हें स्क्रिप्ट चलाते समय सेट किया जा सकता है. ध्यान दें कि हम डिफ़ॉल्ट मान कैसे सेट कर सकते हैं, और चूंकि यह विशेष लैब 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 = "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_model_armor_template. ध्यान दें कि संवेदनशील डेटा फ़िल्टर कॉन्फ़िगरेशन के लिए, हम उन दोनों टेंप्लेट के .name का इस्तेमाल करते हैं जिन्हें हमने पहले बनाया था. इस तरीके का फ़ायदा यह है कि अगर हम Terraform में किसी अन्य संसाधन की डिपेंडेंसी को मिटाने वाले हैं, तो एक चेतावनी दिखती है. इससे डाउनस्ट्रीम की समस्याओं को रोकने में मदद मिलती है. हालांकि, स्क्रिप्ट या कंसोल का इस्तेमाल करते समय ऐसा नहीं होता.

जहां आपने SDP टेम्प्लेट जोड़े थे, उसके नीचे terraform/main.tf में, 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 का इस्तेमाल करके टेंप्लेट आईडी को आउटपुट करने का तरीका है. हमें इसकी ज़रूरत, मल्टी-एजेंट सिस्टम में Model Armor टेंप्लेट को कॉल करने के लिए एनवायरमेंट वैरिएबल के तौर पर होगी. 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 टेंप्लेट को लागू करेंगे. हालांकि, अगर आपको उन्हें अभी लागू करना है, तो मुख्य प्रोजेक्ट फ़ोल्डर से यह कमांड चलाएं:

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

संवेदनशील डेटा की सुरक्षा और Model Armor टेंप्लेट को एक जगह से मैनेज करने के लिए, इन्फ़्रास्ट्रक्चर-एज़-कोड का इस्तेमाल करने से यह पक्का करने में मदद मिलती है कि आपके प्रोजेक्ट के बढ़ने पर, नीतियां लगातार लागू की जाती रहें. इसकी मदद से, एक ही टेंप्लेट का दोबारा इस्तेमाल किया जा सकता है. साथ ही, एक ही जगह से कई प्रोजेक्ट में बदलाव किए जा सकते हैं. इससे मैन्युअल कॉन्फ़िगरेशन या कमज़ोर स्क्रिप्ट से बचा जा सकता है. सुरक्षा टीमों के लिए, कोड की समीक्षा करना भी ज़्यादा आसान होता है. इसकी तुलना में, कंसोल में बदलाव करना ज़्यादा मुश्किल होता है.

9. नतीजा

बधाई हो! आपने डिस्ट्रिब्यूटेड कोर्स क्रिएटर को सुरक्षित कर लिया है.

रीकैप

इस लैब में, आपको ये काम करने होंगे:

  • धमकी का पता लगाने के लिए, Model Armor टेंप्लेट का इस्तेमाल करके सुरक्षा से जुड़ी सख्त नीति तय की. साथ ही, निजी पहचान से जुड़ी जानकारी (पीआईआई) को छिपाने के लिए, एसडीपी टेंप्लेट का इस्तेमाल किया. इन संसाधनों को Terraform IaC की मदद से बनाया गया.
  • हमने एक सुरक्षा लेयर बनाई है. इससे, Model Armor के कॉल को एन्क्रिप्ट (सुरक्षित) किया जाता है. इससे पहले कि कोई नुकसान पहुंचाने वाली चीज़ आपके एजेंट को नुकसान पहुंचाए, यह लेयर उसे सुरक्षित कर देती है.
  • सुरक्षा कंट्रोल की पुष्टि करने के लिए, डिप्लॉय किए गए सिस्टम के ख़िलाफ़ Red Team के टेस्ट किए गए.

प्रोटोटाइप से प्रोडक्शन तक

यह लैब, Google Cloud की मदद से प्रोडक्शन के लिए तैयार एआई के लर्निंग पाथ का हिस्सा है.

  • सुरक्षा को और बेहतर बनाएं: Model Armor को कॉन्फ़िगर करें, ताकि वह इंटरनेट पर की गई खोज के नतीजों को भी फ़िल्टर कर सके. इससे आपके एजेंट, नुकसान पहुंचाने वाले वेब कॉन्टेंट से सुरक्षित रहेंगे. साथ ही, आउटपुट में मौजूद संवेदनशील जानकारी को छिपाने की सुविधा चालू करें, ताकि एजेंट के जवाबों में संवेदनशील डेटा लीक न हो.
  • ऑटोमेटेड रेड टीमिंग: मैन्युअल टेस्टिंग से आगे बढ़कर, रेड टीम के खास एजेंट को डिप्लॉय करें. यह एजेंट, आपके सिस्टम की कमियों का पता लगाने के लिए लगातार जांच करता है.
  • सुरक्षा को प्राथमिकता देना: Gemini का इस्तेमाल करके, सुरक्षा को पहले से ही इंटिग्रेट करें. इससे डिप्लॉयमेंट से पहले, कोड के तौर पर इस्तेमाल किए जाने वाले अपने इन्फ़्रास्ट्रक्चर (Terraform) को गलत कॉन्फ़िगरेशन और अनुपालन से जुड़ी समस्याओं के लिए स्कैन किया जा सकता है.

प्रोटोटाइप से उत्पादन तक के अंतर को पाटने के लिए संपूर्ण पाठ्यक्रम का अन्वेषण करें.

#ProductionReadyAI हैशटैग का इस्तेमाल करके, अपनी प्रोग्रेस शेयर करें.