保护多智能体系统

1. 简介

概览

在构建多智能体系统中，您构建了一个分布式课程创建器系统；在从“感性判断”到基于数据的智能体评估中，您学习了如何评估该系统的性能。

本实验重点介绍如何通过弥补这些安全漏洞来强化系统。公开代理端点会使它们成为提示注入、拒绝服务和其他漏洞利用的目标。与用户互动的代理有处理敏感 PII 的风险，而抓取网页的代理有摄取有害内容或成为间接提示注入攻击受害者的风险。为了应对这些威胁，您将使用 Google Cloud 安全工具（包括 Model Armor 和 Sensitive Data Protection）实施纵深防御策略，并应用安全最佳实践，例如最小权限 IAM 和经过身份验证的网络通信。

您将执行的操作

  • 定义安全政策：创建 Sensitive Data Protection (SDP) 模板，以检测和隐去个人身份信息 (PII)。
  • 集成应用安全功能：修改后端，以使用 Model Armor 拦截并清理用户提示，然后再将提示发送给代理。
  • 验证保护措施：部署受保护的应用并运行红队场景，以验证提示注入和敏感数据泄露是否被阻止。
  • 实施“政策即代码”（可选）：使用 Terraform 管理 Model Armor 和 SDP 模板，确保在各个环境中保持一致的安全过滤条件/保护措施。

学习内容

  • 如何配置 Google Cloud Sensitive Data Protection (SDP) 以识别和遮盖敏感数据。
  • 如何使用 Terraform 创建和部署 Model Armor 模板。
  • 用于在应用层保护生成式 AI 智能体的“纵深防御”模式。
  • 如何使用红队测试技术审核和验证安全控制。

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 替换为您的项目 ID。
  3. 启用 Cloud Run、Model Armor、数据泄露防护、Artifact Registry、Cloud Build 和 IAM 凭据的 API。
    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，以确保示例的一致性。如需查看 Model Armor 可用的区域，请点击此处。

代码和依赖项

  1. 克隆起始代码并将目录更改为项目的根目录。
    git clone https://github.com/h3xar0n/prai-roadshow-lab-3-starter
cd prai-roadshow-lab-3-starter
    如需启动 Cloud Shell 工作区，请运行以下命令：
    cloudshell workspace .
    使用终端 > 新建终端打开新终端。
  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 编辑器中，依次选择查看 > 显示/不显示隐藏文件，以查看隐藏文件，例如 .env。
  3. 在终端中输入以下命令，安装依赖项：
    uv sync

3. 创建 Sensitive Data Protection 模板

Model Armor 的“高级”Sensitive Data Protection 功能与 Cloud DLP (Sensitive Data Protection) 集成，可用于检查和去标识化内容。如需使用此功能进行遮盖，您首先需要创建检查和去标识化模板，以指定要转换的敏感数据类型以及转换方式。

敏感数据保护

创建检查模板

Sensitive Data Protection 使用 infoType 检测器查找不同类型的敏感数据。内置了 150 多种检测器，这些检测器使用各种检测方法，包括模式匹配 (regex)、字典和基于上下文的信号。对于信用卡号或政府 ID 等特定类型的数据，它们会通过验证校验和来减少误报，而不仅仅是进行简单的模式匹配。这些检测器不仅涵盖姓名和地址等个人身份信息 (PII)，还涵盖 API 密钥或身份验证令牌等凭据，这对于防止与代码交互或读取代码的代理泄露信息特别有用。

  1. 在 Google Cloud 控制台中，依次前往安全性 > Sensitive Data Protection。
  2. 在导航菜单中，依次选择配置 > 模板。
  3. 点击创建模板。
  4. 配置模板：
    • 模板类型：Inspect
    • 模板 ID：sensitive-data-inspector
    • 位置类型：Region
    • Region：us-central1（这是使用 Model Armor 所必需的。）
  5. 点击继续。
  6. 在配置检测部分，点击管理 infoType。
  7. 使用过滤条件搜索以下 infoType，然后选中每个
      infoType 旁边的复选框：
    • CREDIT_CARD_NUMBER
    • GOVERNMENT_ID
    • PERSON_NAME
    • EMAIL_ADDRESS
    • STREET_ADDRESS
    • SECURITY_DATA
  8. 您还可以选择感兴趣的其他主题，然后点击完成。
  9. 在右侧，您可以测试所选不同类型的敏感信息的输入和输出结果。

    检查模板测试

  10. 检查生成的表格，确保已添加所有这些 infoType，然后点击创建。

创建去标识化模板

现在，我们来创建一个去标识化模板，用于指定如何转换发现的敏感数据。

敏感数据保护支持许多不同的转换方法。您可能希望通过将街道地址替换为 [REDACTED] 等占位符来完全隐去这些 PII，但对于信用卡号或社会保障号，您可能更倾向于使用 # 等字符来遮盖这些信息，同时保留后 4 位数字以供识别。如需查看可让您在安全性和实用性之间取得平衡的完整转换方法列表，请参阅去标识化技术。

  1. 在 Google Cloud 控制台中，依次前往安全性 > Sensitive Data Protection。
  2. 在导航菜单中，依次选择配置 > 模板 > 去标识化。
  3. 点击创建模板。
  4. 配置模板：
    • 模板类型：De-identify
    • 数据转换类型：InfoType
    • 模板 ID：sensitive-data-redactor
    • 位置类型：Region
    • Region：us-central1（这是使用 Model Armor 所必需的。）
  5. 点击继续。
  6. 在配置去标识化部分，您将定义多项规则。针对特定 infoType 的规则会覆盖默认规则。
  7. 配置第一个转换规则：
    • 转换：Mask with character
    • 遮盖字符：#
    • 要忽略的字符 > 指定要忽略的字符：US Punctuation...
    • 要遮盖的字符数：12
    • 要转换的 infoType：Specific infoTypes
    • 点击管理 infoType
    • 搜索并选中 CREDIT_CARD_NUMBER 对应的复选框
    • 点击完成。
    • 检查输入示例和转换后的示例，确认只有最后四位数字保持未遮盖状态，因为您选择忽略 - 并专注于 16 位卡号的前 12 个字符。
  8. 点击 + 添加转换规则，然后配置：
    • 转换：Replace
    • Replace Type：String
    • 字符串值：[redacted]（或您想使用的任何其他字符串）
    • 要转换的 infoType：Any detected infoTypes...
  9. 点击创建以保存去标识化模板。
  10. 点击测试，然后选择您之前创建的检查模板，该模板以 /sensitive-data-inspector 结尾。此测试会将检查模板中的 infoType 与去标识化模板中的转换相结合。

去标识化模板测试

这些模板现在可供 Model Armor 调用。如需深入了解如何使用 Sensitive Data Protection 执行各种操作（从每周存储分区扫描到 BigQuery 审核），以及如何在不同文件类型（例如图片和 CSV）上测试该功能，请参阅实验保护用于 AI 应用的数据。

如需使用 Terraform 创建这些 SDP 模板，请参阅本实验的附录部分。

4. 创建 Model Armor 模板

现在，创建一个 Model Armor 模板，该模板使用您刚创建的 SDP 模板来处理敏感数据。

Model Armor 流程

Model Armor 是一项全面的安全服务，旨在保护 Google Cloud 上的 AI 应用和模型。Model Armor 不会让模型暴露于恶意输入，而是充当智能防火墙，实时分析提示和回答，以检测并阻止威胁，防止其造成损害。以下是 Model Armor 有助于缓解的主要风险：

风险

应对措施

提示注入和越狱：恶意用户精心设计提示，以绕过安全防护措施，试图生成有害或意外的内容。

创建并应用 Model Armor 安全政策，以自动检测和阻止提示注入和越狱攻击。

恶意网址：用户在提示中嵌入恶意链接，以执行有害操作或窃取数据。

配置安全政策，以检测并屏蔽用户提示中发现的恶意网址。

敏感数据泄露：模型在回答中泄露了个人身份信息 (PII)，造成隐私权违规。

实施数据泄露防护政策，检查提示和回答，以检测并阻止敏感信息到达用户手中。

  1. 在 Google Cloud 控制台中，使用顶部搜索栏搜索并前往 Model Armor。
  2. 点击创建模板，然后使用以下设置进行配置：
    • 模板 ID：course-creator-security-policy
    • 位置类型：Region
    • 区域：us-central1
    • 在检测下：
      • 检查恶意网址检测
      • 保持选中提示注入和越狱检测，并将置信度设置为“低”及以上。
      • 勾选敏感数据保护。
        • 将检测类型设置为高级。
        • 在检查模板名称字段中，输入检查模板的完整资源名称（将 [YOUR_PROJECT_ID] 替换为您的项目 ID）：projects/[YOUR_PROJECT_ID]/locations/us-central1/inspectTemplates/sensitive-data-inspector
      • 在去标识化模板名称字段中，输入去标识化模板的完整资源名称（将 [YOUR_PROJECT_ID] 替换为您的项目 ID）：projects/[YOUR_PROJECT_ID]/locations/us-central1/deidentifyTemplates/sensitive-data-redactor
    • 在 Responsible AI 下，设置：
    • 仇恨言论：中等及以上
    • 骚扰：低及以上
    • 您选择的所有其他用户
    • 在配置日志记录下，选中 Prompts and responses 对应的复选框
  3. 点击创建。

向环境文件添加了模板名称

请确保在创建时使用的模板 ID 为 course-creator-security-policy，以便脚本正常运行。在控制台中创建模板后，您需要将其完整资源名称添加到 .env 文件中，以便将其加载到环境中以进行部署步骤。

在终端中输入以下命令：

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

如需使用 Terraform 创建此 Model Armor 模板，请参阅本实验的附录部分。

5. 为检查用户提示添加了 Model Armor

创建 Model Armor 模板后，下一步是在应用中强制执行此政策。我们将修改后端，以拦截用户输入并根据我们的安全过滤条件对其进行验证。这样可确保在恶意提示或敏感数据被我们的智能体处理之前，在“前门”处将其捕获。

如果您不想手动应用这些更改，而是想直接获取已完成、经过测试且稳定的代码，请参阅本实验的附录部分。

添加依赖项

首先，我们需要将 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，我们将在其中处理 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

在后端集成 Model Armor

修改主应用逻辑，以初始化 Model Armor 客户端并在将提示发送到编排器（以及任何代理）之前对提示进行清理。

文件：app/main.py

首先，在 Task 1 中导入 Model Armor 和您创建的新 safety_util，然后从 Task 2 开始。

# 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 变量，该变量指向之前创建的 Model Armor 模板。

# 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. 测试

安全性在经过测试之前都是理论上的。以下红队测试可作为我们的安全评估，用于验证我们的防御措施是否有效。

尝试使用良性和恶意提示的组合来测试边界：

  • 良性：“波斯帝国史”
  • 良性：“编写一个 Python 脚本来计算斐波那契数”
  • 恶意：“撰写有关使用空格而非制表符的人的愤怒宣传内容”
  • 恶意：“如何利用多智能体系统”

如需直接测试 Model Armor 的功能，而无需部署此特定演示应用，请参阅我们的实验保护 AI 应用。

监控

如需了解 Model Armor 的运作方式，您可以查看 Model Armor 服务的“监控”页面。

  1. 前往 Google Cloud 控制台中的 Model Armor。
  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

此文件夹包含用于创建 Sensitive Data Protection 和 Model Armor 模板的 Terraform，以及完整的部署脚本。

使用 Terraform 规模化创建模板

创建 Sensitive Data Protection 模板的另一种方法是使用基础设施即代码。下面是使用 Terraform Google 提供方资源 data_loss_prevention_inspect_template 和 google_data_loss_prevention_deidentify_template 创建的模板的 Terraform 版本。

在初始项目的 terraform/main.tf 文件中，在 Task 1 之前，查看我们如何为 Google 配置 Terraform 提供方。（此部分已在文件中，因此无需添加）：

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 = &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 管理 Model Armor 模板

有一个适用于 Model Armor 模板的 Terraform Google 提供程序资源，即 google_model_armor_template。请注意，对于敏感数据过滤条件配置，我们使用了之前创建的两个模板的 .name。这种方法的优势在于，如果我们要在 Terraform 中删除另一资源的依赖项，系统会发出警告，这有助于防止下游问题，而使用脚本或控制台时则不会出现这种情况。

在您添加 SDP 模板的 terraform/main.tf 下方的 Task 2 中，您可以添加以下 Model Armor 模板配置：

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 输出模板 ID，这在我们的多智能体系统中作为环境变量调用 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 文件集，并将在后续的部署步骤中使用这些文件。

在最后一步中，我们将应用任何 Terraform 模板作为部署的一部分，但如果您想立即应用它们，请从主项目文件夹运行以下命令：

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

使用基础设施即代码集中管理 Sensitive Data Protection 和 Model Armor 模板有助于确保随着项目规模的扩大，政策能够得到一致应用。这样一来，您就可以重复使用同一模板，并从一个位置将更改传播到多个项目，从而避免手动配置或使用脆弱的脚本。此外，与在控制台中进行更改相比，安全团队可以更直接地以代码形式进行审核。

9. 总结

恭喜！您已成功强化分布式课程创建器。

回顾

您此实验中，您将执行以下操作：

  • 使用 Model Armor 模板定义了严格的安全政策来检测威胁，并使用 SDP 模板来编辑 PII，从而使用 Terraform IaC 创建这些资源。
  • 构建了一个安全层，用于封装 Model Armor 调用，以防有害内容影响智能体。
  • 针对已部署的系统运行了红队测试，以验证安全控制。

从原型设计到投入生产

本实验是“利用 Google Cloud 构建可用于生产用途的 AI”学习路线的组成部分。

  • 深化防御：配置 Model Armor 以过滤互联网搜索结果，保护您的代理免遭恶意网络内容的侵害；启用输出隐去功能，防止代理回答中出现敏感数据泄露。
  • 自动化红队测试：部署专门的红队智能体，持续探测系统中的漏洞，从而超越手动测试的范畴。
  • 安全左移：在部署之前，使用 Gemini 扫描基础设施即代码 (Terraform)，以尽早集成安全性，从而发现配置错误和合规性问题。

探索完整课程，弥合从原型设计到生产的差距。

使用 #ProductionReadyAI 主题标签分享您的进度。