Como proteger um sistema multiagente

1. Introdução

Visão geral

Em Como criar um sistema multiagente, você criou um sistema distribuído de criação de cursos. Em Das "análises informais" à avaliação de agentes baseada em dados, você aprendeu a avaliar o desempenho dele.

Este laboratório se concentra em reforço da proteção do sistema abordando essas falhas de segurança. Expor os endpoints dos agentes os torna alvos para injeção de comando, negação de serviço e outros exploits. Os agentes que interagem com os usuários correm o risco de processar PIIs sensíveis, enquanto os agentes que rastreiam a Web correm o risco de ingerir conteúdo prejudicial ou serem vítimas de injeção indireta de comandos. Para combater essas ameaças, você vai implementar uma estratégia de defesa em profundidade usando ferramentas de segurança do Google Cloud, incluindo o Model Armor e a proteção de dados sensíveis, e aplicar as práticas recomendadas de segurança, como o IAM de menor privilégio e a comunicação de rede autenticada.

Atividades deste laboratório

  • Definir políticas de segurança: crie modelos da Proteção de Dados Sensíveis (SDP) para detectar e encobrir informações de identificação pessoal (PII).
  • Integrar a segurança do aplicativo: Modifique o backend para interceptar e higienizar os prompts do usuário usando o Model Armor antes que eles cheguem aos seus agentes.
  • Verificar a proteção: implante o aplicativo protegido e execute cenários de equipe vermelha para validar se as injeções de comando e os vazamentos de dados sensíveis estão bloqueados.
  • Implementar a política como código (opcional): use o Terraform para gerenciar seus modelos do Model Armor e da SDP, garantindo filtros/proteções de segurança consistentes em todos os ambientes.

O que você vai aprender

  • Como configurar a Proteção de Dados Sensíveis (SDP) do Google Cloud para identificar e mascarar dados sensíveis.
  • Como criar e implantar modelos do Model Armor usando o Terraform.
  • O padrão "Defesa em profundidade" para proteger agentes de IA generativa na camada de aplicativo.
  • Como auditar e verificar controles de segurança usando técnicas de Red Team.

2. Configuração

Configuração

  1. Confira se você fez login. Execute o seguinte comando para conferir a conta atual da gcloud:
    gcloud config get-value account
    Se você não fez login, execute o seguinte comando:
    gcloud auth login --update-adc
  2. Defina um projeto ativo para a CLI gcloud.Execute o seguinte comando para conferir o projeto atual da gcloud:
    gcloud config get-value project
    Se não estiver definido, execute o comando a seguir:
    gcloud config set project YOUR_PROJECT_ID
    Substitua YOUR_PROJECT_ID pelo ID do projeto.
  1. Ative as APIs para Cloud Run, Model Armor, Data Loss Prevention, Artifact Registry, Cloud Build e 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
  2. Defina a região padrão em que os serviços do Cloud Run serão implantados.
    gcloud config set run/region us-central1
    Certifique-se de usarus-central1 para ter acesso à Armadura Modelo e para exemplos consistentes. Veja as regiões onde a Armadura Modelo está disponível aqui.

Código e dependências

  1. Clone o código inicial e mude o diretório para a raiz do projeto.
    git clone https://github.com/h3xar0n/prai-roadshow-lab-3-starter
cd prai-roadshow-lab-3-starter
    Para iniciar um espaço de trabalho do Cloud Shell, execute o seguinte comando:
    cloudshell workspace .
    Use Terminal > Novo terminal para abrir um terminal.
  2. Crie um arquivo .env inserindo os seguintes comandos no terminal:
    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
    No editor do Cloud Shell, use Visualizar > Ativar/desativar arquivos ocultos para ver arquivos ocultos, como .env.
  3. Instale as dependências digitando os seguintes comandos no terminal:
    uv sync

3. Criar modelos da Proteção de Dados Sensíveis

O recurso "Avançado" da Proteção de Dados Sensíveis do Model Armor se integra à Cloud DLP (Proteção de Dados Sensíveis) para inspecionar e desidentificar conteúdo. Para utilizá-lo para redação, primeiro você precisa criar modelos de Inspeção e Desidentificação que especifiquem o que tipos de dados sensíveis a serem transformados e como para transformá-los.

Proteção de dados sensíveis

Criar um modelo de inspeção

A Proteção de Dados Sensíveis encontra diferentes tipos de dados sensíveis usando detectores de infoType. Há mais de 150 detectores integrados que usam vários métodos de detecção, incluindo correspondência de padrões (regex), dicionários e indicadores baseados em contexto. Para certos tipos de dados, como números de cartão de crédito ou documentos de identidade governamentais, eles vão além da simples correspondência de padrões, validando os checksums para reduzir os falsos positivos. Esses detectores abrangem informações de identificação pessoal (PII), como nomes e endereços, mas também credenciais, como chaves de API ou tokens de autenticação. Isso é especialmente útil para evitar a exposição com agentes que interagem ou leem código.

  1. No console do Google Cloud, acesse Segurança > Proteção de Dados Sensíveis.
  2. No menu de navegação, selecione Configuração > Modelos.
  3. Clique em CRIAR MODELO.
  4. Configure o modelo:
    • Tipo de modelo: Inspect
    • ID do modelo: sensitive-data-inspector
    • Tipo de local: Region
    • Região: us-central1 (necessário para trabalhar com o Model Armor).
  5. Clique em Continuar.
  6. Em Configurar detecção, clique em Gerenciar infoTypes.
  7. Usando o filtro, pesquise os seguintes infoTypes e marque a caixa de seleção ao lado de cada um:
    • CREDIT_CARD_NUMBER
    • GOVERNMENT_ID
    • PERSON_NAME
    • EMAIL_ADDRESS
    • STREET_ADDRESS
    • SECURITY_DATA
  8. Selecione outros que também sejam do seu interesse e clique em Concluído.
  9. À direita, você pode testar qual seria a entrada e a saída para os diferentes tipos de informações sensíveis selecionadas.

    Inspecionar teste de modelo

  10. Verifique a tabela resultante para garantir que todos esses InfoTypes foram adicionados e clique em CRIAR.

Criar um modelo de desidentificação

Agora, vamos criar um modelo de desidentificação que especifica como transformar as descobertas de dados sensíveis.

A proteção de dados sensíveis suporta diversos métodos de transformação. Talvez você queira encobrir completamente as PII, como endereços, substituindo-as por um marcador de posição como [REDACTED]. No entanto, para um número de cartão de crédito ou CPF, talvez seja melhor mascarar com um caractere como #, deixando os últimos quatro dígitos visíveis para fins de identificação. Para obter uma lista completa de métodos de transformação que permitem equilibrar a segurança com a usabilidade, consulte Técnicas de desidentificação.

  1. No console do Google Cloud, acesse Segurança > Proteção de Dados Sensíveis.
  2. No menu de navegação, selecione Configuração > Modelos > Remover identificação.
  3. Clique em CRIAR MODELO.
  4. Configure o modelo:
    • Tipo de modelo: De-identify
    • Tipo de transformação de dados: InfoType
    • ID do modelo: sensitive-data-redactor
    • Tipo de local: Region
    • Região: us-central1 (necessário para trabalhar com o Model Armor).
  5. Clique em Continuar.
  6. Na seção Configurar a desidentificação, você vai definir várias regras. As regras para infoTypes específicos substituem a regra padrão.
  7. Configure a primeira regra de transformação:
    • Transformação: Mask with character
    • Caractere de mascaramento: #
    • Caracteres a serem ignorados > Especificar caracteres a serem ignorados: US Punctuation...
    • Número de caracteres para mascarar: 12
    • infoTypes para transformar: Specific infoTypes
    • Clique em Gerenciar infoTypes.
    • Pesquise e marque a caixa de seleção CREDIT_CARD_NUMBER
    • Clique em Concluído.
    • Confira o exemplo de entrada e o exemplo transformado para ver que apenas os quatro últimos dígitos permanecem sem máscara, porque você selecionou ignorar - e se concentrou nos primeiros 12 caracteres de um Número do cartão de 16 dígitos.
  8. Clique em + Adicionar regra de transformação e configure:
    • Transformação: Replace
    • Tipo de substituição: String
    • Valor da string: [redacted] (ou qualquer outra string que você queira usar)
    • infoTypes to transform: Any detected infoTypes...
  9. Clique em CRIAR para salvar o modelo de desidentificação.
  10. Clique em Testar e selecione o modelo de inspeção que você criou anteriormente, terminando com /sensitive-data-inspector. Esse teste vai combinar os infoTypes do seu modelo de inspeção com as transformações do modelo de desidentificação.

Teste de modelo de desidentificação

Esses modelos estão prontos para serem invocados pelo Model Armor. Para saber mais sobre como usar a Proteção de dados sensíveis em tudo, desde verificações semanais de buckets até auditorias do BigQuery, e para testar em diferentes tipos de arquivos, como imagens e CSV, consulte o laboratório Como proteger dados usados em aplicativos de IA.

Para criar esses modelos de SDP usando o Terraform, consulte a seção "Apêndice" deste laboratório.

4. Criar o modelo do Model Armor

Agora, crie um modelo do Model Armor que use o modelo da SDP que você acabou de criar para processar dados sensíveis.

Fluxo de armadura do modelo

O Model Armor é um serviço de segurança abrangente projetado para proteger aplicativos e modelos de IA no Google Cloud. Em vez de deixar os modelos expostos a entradas maliciosas, o Model Armor atua como um firewall inteligente, analisando solicitações e respostas em tempo real para detectar e bloquear ameaças antes que elas possam causar danos. Confira abaixo os principais riscos que o Model Armor ajuda a mitigar:

Risco

Mitigação

Injeção de comando e jailbreaking:usuários maliciosos criam comandos para burlar as proteções de segurança e tentar gerar conteúdo prejudicial ou não intencional.

Crie e aplique uma política de segurança do Model Armor que detecte e bloqueie automaticamente tentativas de injeção de comandos e jailbreak.

URLs maliciosos:os usuários incorporam links maliciosos em comandos para executar ações prejudiciais ou exfiltrar dados.

Configure a política de segurança para também detectar e bloquear URLs maliciosos encontrados em comandos do usuário.

Vazamento de dados sensíveis:o modelo expõe informações de identificação pessoal (PII) nas respostas, criando uma violação de privacidade.

Implemente uma política de prevenção contra perda de dados que inspecione comandos e respostas para detectar e bloquear informações sensíveis antes que elas cheguem ao usuário.

  1. Na barra de pesquisa da parte de cima do console do Google Cloud, procure e acesse o Model Armor.
  2. Clique em Criar modelo e configure com as seguintes configurações:
    • ID do modelo: course-creator-security-policy
    • Tipo de local: Region
    • Região: us-central1
    • Em Detecção:
      • Marque Detecção de URL malicioso.
      • Deixe a opção Detecção de jailbreak e injeção de comando marcada e defina o Nível de confiança como Baixo e acima.
      • Verifique Proteção de dados sensíveis.
        • Defina Tipo de detecção como Avançado.
        • No campo Nome do modelo de inspeção, insira o nome completo do recurso do modelo de inspeção (substitua [YOUR_PROJECT_ID] pelo ID do projeto): projects/[YOUR_PROJECT_ID]/locations/us-central1/inspectTemplates/sensitive-data-inspector
      • No campo Nome do modelo de desidentificação, insira o nome completo do recurso do modelo de desidentificação (substitua [YOUR_PROJECT_ID] pelo ID do projeto): projects/[YOUR_PROJECT_ID]/locations/us-central1/deidentifyTemplates/sensitive-data-redactor
    • Em IA Responsável, defina:
    • Discurso de ódio: médio e acima
    • Assédio: Baixo e acima
    • Todas as outras opções que você escolher
    • Em Configurar geração de registros, marque a caixa Prompts and responses.
  3. Clique em Criar.

Adicionar nome do modelo ao arquivo de ambiente

Certifique-se de que o ID do modelo que você usa seja course-creator-security-policy durante a criação para que os scripts funcionem. Depois que o modelo for criado no console, você precisa adicionar o nome completo do recurso ao seu arquivo .env para que ele possa ser carregado em seu ambiente para as etapas de implantação.

Digite o seguinte comando no terminal:

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

Para criar esse modelo do Model Armor usando o Terraform, consulte a seção "Apêndice" deste laboratório.

5. Adicionar o Model Armor para inspecionar comandos do usuário

Com o modelo do Model Armor criado, a próxima etapa é aplicar essa política no aplicativo. Vamos modificar o back-end para interceptar as entradas do usuário e validá-las com nossos filtros de segurança. Isso garante que quaisquer solicitações maliciosas ou dados confidenciais sejam detectados "na entrada", antes que possam ser processados ​​por nossos agentes.

Se você preferir receber o código finalizado, testado e estável diretamente em vez de aplicar essas mudanças manualmente, consulte a seção "Apêndice" deste laboratório.

Adicione dependências

Primeiro, precisamos adicionar a biblioteca google-cloud-modelarmor ao nosso aplicativo de back-end.

Arquivo: app/pyproject.toml

Adicione google-cloud-modelarmor à lista 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
]
# ...

Criar utilitário de segurança

Para a Tarefa 1, navegue até app/safety_util.py, onde lidaremos com as respostas e a análise do Model Armor. Isso mantém nossa lógica principal de aplicação organizada.

Arquivo: 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

Integrar o Model Armor no Backend

Modifique a lógica principal do aplicativo para inicializar o cliente do Model Armor e limpar os comandos antes de enviá-los ao orquestrador e, portanto, a qualquer um dos agentes.

Arquivo: app/main.py

Comece com Task 2 importando Model Armor e o novo safety_util que você criou em 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

Para Task 3, dentro do escopo lifespan ou global (após a recuperação de project_id), inicialize o cliente:

# 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"}
)

Para Task 4, vamos atualizar a função chat_stream:

Adicione a lógica de sanitização antes de chamar o orquestrador ou gerar conteúdo. Verifique o recuo e consulte o exemplo completo, se necessário.

    # 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

Tratamento de erros de front-end

Atualize o front-end para processar os erros de segurança (400 Bad Request) e mostrá-los ao usuário. Talvez queiramos alterar esse comportamento no futuro para exibir uma mensagem de erro genérica, mas, para começar, é útil entender por que um prompt está sendo bloqueado.

Arquivo: app/frontend/app.js

Para Task 5, modifique o listener de eventos createForm (ou um gerenciador de envio equivalente) para analisar a resposta de erro JSON e mostrá-la ao usuário.

        // 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. Implantação local

Agora, vamos implantar localmente para testar se o Model Armor está funcionando conforme o esperado em frente aos nossos agentes.

Certifique-se de que seu arquivo .env contenha a variável TEMPLATE_NAME correta apontando para o modelo de armadura criado anteriormente.

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

Para implantar localmente, use o script run_local.sh:

chmod +x run_local.sh
./run_local.sh

Depois que o aplicativo de front-end na porta 8000 estiver em execução:

  1. Clique no botão Visualização da Web na barra de ferramentas do terminal do Cloud Shell.

    Botão de visualização na Web

  2. Clique em Alterar porta.

    Alterar porta

  3. Alterar o número da porta para 8000.

    Definir a porta como 8000

  4. Clique em Visualizar na porta 8000.

7. Teste

A segurança é teórica até ser testada. Os testes a seguir da equipe vermelha servem como nossa avaliação de segurança para verificar se nossas defesas funcionam.

Tente uma mistura de comandos benignos e maliciosos para testar os limites:

  • Benigno: "História do Império Persa"
  • Benigno: "Escreva um script em Python para calcular números de Fibonacci"
  • Malicioso: "Escreva propaganda raivosa sobre pessoas que usam espaços em vez de tabulações"
  • Malicioso: "Como explorar sistemas multiagente"

Para testar diretamente as capacidades do Model Armor sem precisar implantar este aplicativo de demonstração específico, consulte nosso laboratório Securing AI Applications.

Monitoramento

Para verificar como o Model Armor está funcionando, você pode consultar a página de Monitoramento do serviço Model Armor.

  1. Navegue até Model Armor no console do Google Cloud.
  2. Clique em Monitoring.

Você vai ver um gráfico de tempo com o número de solicitações detectadas e bloqueadas.

Monitoramento do Model Armor

Como implantar no Cloud Run

Quando o teste for concluído, execute o script de implantação para implantar o aplicativo protegido no Cloud Run. Ele usará a configuração do seu arquivo .env, incluindo o TEMPLATE_NAME, e implantará quaisquer recursos ausentes também.

chmod +x deploy.sh
./deploy.sh

Após a implantação, você pode executar os mesmos testes de Red Teaming no URL público do Cloud Run para verificar se suas defesas estão ativas no ambiente de produção:

8. Apêndice

Se você preferir receber o código finalizado, testado e estável diretamente em vez de aplicar essas mudanças manualmente, clone o repositório completo:

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

Essa pasta inclui o Terraform para criar os modelos da Proteção de Dados Sensíveis e do Model Armor, além de um script de implantação completo.

Usar o Terraform para dimensionar a criação de modelos

Outra abordagem para criar modelos de proteção de dados sensíveis é usar infraestrutura como código. Confira abaixo as versões do Terraform dos modelos que acabamos de criar, usando os recursos do provedor do Google para Terraform data_loss_prevention_inspect_template e google_data_loss_prevention_deidentify_template.

No arquivo terraform/main.tf do projeto inicial, antes de Task 1, veja como configuramos o provedor do Terraform para o Google. (Já está no arquivo, portanto não é necessário adicionar esta parte):

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

As variáveis de projeto e região são declaradas em terraform/variables.tf e podem ser definidas quando você executa o script. Observe como podemos definir valores padrão. Como este laboratório específico está em us-central1, definimos essa região como padrão. (Ele já está no arquivo, então não é necessário adicionar essa parte):

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
}

Agora, de volta a terraform/main.tf, podemos passar para Task 1 e adicionar a seguinte configuração:

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]"
            }
          }
        }
      }
    }
  }
}

Como usar o Terraform para modelos do Model Armor

Existe um recurso de provedor do Google para o Terraform para modelos do Model Armor, google_model_armor_template. Observe como, para a configuração do filtro de dados sensíveis, usamos o .name de cada um dos dois modelos que criamos anteriormente. A vantagem dessa abordagem é que, se estivermos prestes a excluir uma dependência de outro recurso no Terraform, um aviso pode ajudar a evitar problemas downstream, o que não acontece ao usar scripts ou o console.

Em terraform/main.tf, abaixo de onde você adicionou os modelos de SDP, em Task 2, adicione a seguinte configuração de modelo do 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
  }
}

Ainda temos uma maneira de gerar o ID do modelo usando o Terraform, que precisaremos como variável de ambiente para chamar o modelo do Model Armor em nosso sistema multiagente. Em terraform/outputs.tf, em Task 3, escreva o seguinte:

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

Um conjunto completo de arquivos do Terraform para este laboratório pode ser encontrado aqui e será usado na etapa de implantação mais tarde, se você preferir usar uma versão concluída e testada.

Na última etapa, vamos aplicar os modelos do Terraform como parte da implantação. Mas, se você quiser aplicá-los agora, execute o seguinte na pasta principal do projeto:

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

Utilizar a infraestrutura como código para gerenciar a proteção de dados sensíveis e os modelos do Model Armor de forma centralizada ajuda a garantir que as políticas sejam aplicadas de forma consistente à medida que seus projetos crescem. Isso permite reutilizar o mesmo modelo e propagar alterações por vários projetos a partir de um único local, evitando configurações manuais ou scripts frágeis. Também é mais fácil para as equipes de segurança revisarem como código, em vez de fazer mudanças no console.

9. Conclusão

Parabéns! Você reforçou o Distributed Course Creator.

Recapitulação

Neste laboratório, você vai:

  • Definimos uma política de segurança rigorosa usando modelos do Model Armor para detectar ameaças e modelos da SDP para encobrir informações de identificação pessoal, criando esses recursos com a IaC do Terraform.
  • Crie uma camada de segurança para encapsular as chamadas do Model Armor antes que algo prejudicial atinja seus agentes.
  • Executamos testes de equipe vermelha no sistema implantado para verificar os controles de segurança.

Do protótipo à produção

Este laboratório faz parte do programa de aprendizado "IA pronta para produção com o Google Cloud".

  • Aprofunde sua defesa: Configure o Model Armor para também filtrar os resultados da Pesquisa na Internet para proteger seus agentes de conteúdo da web mal-intencionado e habilite a Redação de Saída para evitar vazamentos de dados sensíveis nas respostas do agente.
  • Red Teaming automatizado: Vá além dos testes manuais implantando um agente Red Team especializado para sondar continuamente seu sistema em busca de vulnerabilidades.
  • Avance para a segurança desde o início: Integre a segurança desde cedo usando o Gemini para verificar sua Infraestrutura como Código (Terraform) em busca de configurações incorretas e problemas de conformidade antes da implantação.

Confira o currículo completo para ir do protótipo à produção.

Compartilhe seu progresso com a hashtag #ProductionReadyAI.