Definir configurações mínimas

Este documento explica como visualizar e atualizar as configurações mínimas do Model Armor e fornece um exemplo de violação dessas configurações.

As configurações de valor mínimo têm dois propósitos principais:

Conformidade do modelo: verifique se os novos modelos são pelo menos tão restritivos quanto os definidos nas configurações mínimas. A conformidade do modelo é definida nos níveis da organização e da pasta.
Aplicação inline: aplique proteções do Model Armor a modelos do Gemini e servidores MCP do Google Cloud. A aplicação inline é configurada no nível do projeto. Ao usar configurações mínimas para aplicação inline, é necessário que o modelo esteja em conformidade.

Antes de começar

Antes de começar, conclua as seguintes tarefas:

Receber as permissões necessárias

Para receber as permissões necessárias para gerenciar as configurações de limite mínimo, peça ao administrador para conceder a você o papel do IAM de Administrador de configurações de limite mínimo do Model Armor (roles/modelarmor.floorSettingsAdmin) nas configurações de limite mínimo do Model Armor. Para mais informações sobre a concessão de papéis, consulte Gerenciar o acesso a projetos, pastas e organizações.

Também é possível conseguir as permissões necessárias usando papéis personalizados ou outros papéis predefinidos.

Ativar APIs

É necessário ativar as APIs do Model Armor antes de usar o Model Armor.

Console

Enable the Model Armor API.
Roles required to enable APIs
To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.
Enable the API
Selecione o projeto em que você quer ativar o Model Armor.

gcloud

Antes de começar, siga estas etapas usando a Google Cloud CLI com a API Model Armor:

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

Execute o comando a seguir para usar o endpoint global da API:

gcloud config set api_endpoint_overrides/modelarmor "https://modelarmor.googleapis.com/"

Aplicativo de configurações mínimas

As configurações locais são sempre aplicadas. Por exemplo, se as configurações de limite mínimo entrarem em conflito, as configurações mais baixas na hierarquia de recursos terão precedência. Da mesma forma, as configurações mínimas definidas no nível do projeto substituem as configurações mínimas conflitantes definidas no nível da pasta acima.

As tabelas a seguir mostram como as configurações de andar são aplicadas em diferentes locais:

Localização das configurações mínimas	Aplicativo
Nível da organização	Se aplica a tudo na organização.
Nível da pasta	É aplicável a todos os projetos dentro dessa pasta específica.
Nível do projeto	Se aplica apenas a um projeto específico.

Para ilustrar como as configurações mínimas são aplicadas quando definidas em diferentes níveis, considere o exemplo a seguir. Suponha que você tenha definido configurações mínimas semelhantes a estas:

Configurações mínimas no nível da pasta (menos específicas): todo o conteúdo desta pasta precisa ativar um filtro de URI malicioso.
Configurações mínimas no nível do projeto (mais específicas): seu projeto, localizado na pasta, precisa usar a detecção de injeção de comando e jailbreak, definida como confiança média.

Nesse cenário, as configurações definidas resultam no seguinte:

Todos os modelos criados no projeto precisam incluir o filtro de detecção de injeção de comandos e jailbreak, porque as configurações no nível do projeto sempre têm precedência sobre as configurações no nível da pasta.
Um modelo criado em um projeto diferente, mesmo que seja em uma pasta diferente, não é afetado pela regra de filtro de URI malicioso da primeira pasta.

As configurações de piso são aplicadas apenas no lugar específico na hierarquia, a menos que sejam definidas no nível da organização, caso em que são aplicadas em toda a organização.

Conformidade de modelos e configurações mínimas

Quando um modelo do Model Armor é criado ou atualizado, ele verifica se a configuração do modelo está em conformidade com as configurações mínimas. Não é possível criar ou atualizar um modelo menos restrito que as configurações de preço mínimo.

As configurações mínimas podem ser definidas no nível da organização, da pasta e do projeto. A interface do usuário está disponível apenas para o nível do projeto e permite herdar as configurações da organização ou da pasta. Para definir as configurações de preço mínimo no nível da organização ou da pasta, use a API.

Integração com servidores MCP da Vertex AI e do Google Cloud

O Model Armor se integra à Vertex AI e aos servidores MCP do Google Cloud para analisar solicitações e respostas dos modelos do Gemini e dos servidores MCP remotos com base nas configurações mínimas definidas.Google Cloud É necessário ativar o Cloud Logging para ter visibilidade dos comandos e respostas. Para mais informações, consulte Integração do Model Armor com a Vertex AI e Integração do Model Armor com servidores do Google Cloud MCP

Definir configurações mínimas

Você usa as configurações mínimas para configurar os limites básicos de detecção dos modelos do Model Armor. Essas configurações verificam se todos os modelos novos e modificados atendem a determinados requisitos.

Para configurar as opções de piso, faça o seguinte:

No console do Google Cloud , acesse a página Model Armor.
Acessar o Model Armor
Selecione um projeto.
Na página Model Armor, acesse a guia Configurações de limite mínimo e clique em Configurar configurações de limite mínimo.
Na página Configurar opções de piso, selecione a opção de configuração.
Na seção Detecções, configure as configurações de detecção.
Opcional: se você selecionar a detecção da Proteção de Dados Sensíveis, será necessário configurar as opções da Proteção de Dados Sensíveis.
Na seção IA responsável, defina o nível de confiança para cada filtro de conteúdo.

Observação: se você não especificar um nível de confiança, o padrão será Médio e acima.
Na seção Serviços, escolha os serviços em que essas configurações mínimas serão aplicadas.
Na seção Registros, selecione Ativar o Cloud Logging para registrar todos os comandos do usuário, as respostas do modelo e os resultados do detector de configurações mínimas.
Selecione Ativar suporte para vários idiomas para usar as configurações de detecção de vários idiomas.
Clique em Salvar configurações de piso.

Aguarde alguns minutos para que as mudanças nas configurações de piso entrem em vigor.

Definir como as configurações mínimas são herdadas

Ao configurar as opções mínimas, selecione a opção de configuração.

Herdar as configurações mínimas do nível pai: herda as configurações mínimas definidas em um nível mais alto na hierarquia de recursos. Clique em Salvar configurações de piso e pule as próximas etapas. Para conferir as configurações herdadas, acesse a guia Configurações de piso.

Observação: quando você ativa a herança, as configurações de preço mínimo atuais são substituídas pelas configurações herdadas.
Personalizado: defina as configurações mínimas para este projeto. As configurações personalizadas definidas para um projeto substituem as configurações mínimas herdadas.
Desativar: desativa todas as configurações mínimas herdadas, o que significa que nenhuma regra de detecção é aplicada aos modelos do Model Armor e à Vertex AI para suas cargas de trabalho do Gemini. Clique em Salvar configurações de piso e pule as próximas etapas. Confira o status desativado na guia Configurações de valor mínimo.

Definir onde as configurações mínimas são aplicadas

Selecione um dos seguintes serviços em que as configurações mínimas configuradas são aplicadas.

Model Armor: criação e atualização de modelos: todos os modelos novos e modificados do Model Armor em um projeto são verificados para garantir que as configurações mínimas sejam especificadas de acordo com as configurações mínimas.

Observação: as configurações de planta não verificam a conformidade dos modelos com a Proteção de dados sensíveis.
Servidor MCP do Google: as solicitações enviadas para ou de servidores MCP remotos do Google ou do Google Cloud são verificadas para garantir que atendam aos limites de configuração mínima. Para mais informações, consulte Integração do Model Armor com servidores do Google Cloud MCP (prévia).
Vertex AI: filtra solicitações enviadas aos modelos do Gemini e registra ou bloqueia aquelas que atendem aos limites mínimos de configuração.

Se você selecionar Vertex AI, a seção Vertex AI vai aparecer, e você poderá escolher como as configurações de restrição são aplicadas.
- Somente inspeção: detecta solicitações que não seguem as configurações mínimas, mas não as bloqueia.
- Inspecionar e bloquear violações: detecte e bloqueie solicitações que não atendem às configurações mínimas.

Ver configurações mínimas do Model Armor

Consulte as configurações mínimas do Model Armor para verificar as configurações atuais, identificar os requisitos mínimos dos seus aplicativos de IA ou resolver problemas quando um modelo não está funcionando como esperado.

Execute o comando a seguir para conferir as configurações mínimas do Model Armor.

Console

No console do Google Cloud , acesse a página Model Armor.

Acessar o Model Armor
Verifique se você está visualizando o projeto em que ativou o Model Armor.
Na página Model Armor, acesse a guia Configurações de preço mínimo. Se as configurações mínimas forem definidas no nível da organização, elas vão aparecer aqui. Se nenhuma configuração de preço mínimo for definida, você precisará configurá-las. Para mais informações, consulte Configurar opções de piso.

gcloud

Confira a configuração mínima do Model Armor para um projeto específico.

  gcloud model-armor floorsettings describe \
      --full-uri='projects/PROJECT_ID/locations/global/floorSetting'

Confira a configuração mínima do Model Armor para uma determinada organização.

  gcloud model-armor floorsettings describe \
      --full-uri='organizations/ORGANIZATION_ID/locations/global/floorSetting'

Confira a configuração mínima do Model Armor para uma determinada pasta.
```
   gcloud model-armor floorsettings describe \
       --full-uri='folders/FOLDER_ID/locations/global/floorSetting'
```
Substitua:
- PROJECT_ID: o ID do projeto para as configurações de limite mínimo.
- FOLDER_ID: o ID da pasta para as configurações de valor mínimo.
- ORGANIZATION_ID: o ID da organização para as configurações de preço mínimo.

REST

Confira a configuração mínima do Model Armor para um projeto específico.

curl -X GET \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "Content-Type: application/json" \
  "https://modelarmor.googleapis.com/v1/projects/PROJECT_ID/locations/global/floorSetting"

Confira a configuração mínima do Model Armor para uma determinada pasta.

curl -X GET \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "Content-Type: application/json" \
  "https://modelarmor.googleapis.com/v1/folders/FOLDER_ID/locations/global/floorSetting"

Confira a configuração mínima do Model Armor para uma determinada organização.

curl -X GET \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "Content-Type: application/json" \
  "https://modelarmor.googleapis.com/v1/organizations/ORGANIZATION_ID/locations/global/floorSetting"

Substitua:

PROJECT_ID: o ID do projeto para as configurações de limite mínimo.
FOLDER_ID: o ID da pasta para as configurações de valor mínimo.
ORGANIZATION_ID: o ID da organização para as configurações de preço mínimo.

C#

Para executar esse código, primeiro configure um ambiente de desenvolvimento em C# e instale o SDK do Model Armor para C#.

Confira a configuração mínima do Model Armor para um projeto específico.

using Google.Cloud.ModelArmor.V1;
using System;

public class GetProjectFloorSettings
{
    public FloorSetting GetProjectFloorSetting(string projectId)
    {
        // Initialize client
        ModelArmorClient client = ModelArmorClient.Create();

        // Construct the resource name
        string name = $"projects/{projectId}/locations/global/floorSetting";

        // Create the request
        GetFloorSettingRequest request = new GetFloorSettingRequest { Name = name };

        // Make the request
        FloorSetting response = client.GetFloorSetting(request);

        Console.WriteLine($"Floor settings retrieved successfully: {response}");

        return response;
    }
}

Confira a configuração mínima do Model Armor para uma determinada pasta.

using Google.Cloud.ModelArmor.V1;
using System;

public class GetFolderFloorSettings
{
    public FloorSetting GetFolderFloorSetting(string folderId)
    {
        // Initialize client.
        ModelArmorClient client = ModelArmorClient.Create();

        // Construct the resource name.
        string name = $"folders/{folderId}/locations/global/floorSetting";

        // Create the request.
        GetFloorSettingRequest request = new GetFloorSettingRequest { Name = name };

        // Make the request.
        FloorSetting response = client.GetFloorSetting(request);

        return response;
    }
}

Confira a configuração mínima do Model Armor para uma determinada organização.

using Google.Cloud.ModelArmor.V1;
using System;

public class GetOrganizationFloorSettings
{
    public FloorSetting GetOrganizationFloorSetting(string organizationId)
    {
        // Initialize client
        ModelArmorClient client = ModelArmorClient.Create();

        // Construct the resource name
        string name = $"organizations/{organizationId}/locations/global/floorSetting";

        // Create the request
        GetFloorSettingRequest request = new GetFloorSettingRequest { Name = name };

        // Make the request
        FloorSetting response = client.GetFloorSetting(request);

        Console.WriteLine($"Floor settings retrieved successfully: {response}");

        return response;
    }
}

Go

Para executar esse código, primeiro configure um ambiente de desenvolvimento do Go e instale o SDK do Model Armor para Go.

Confira a configuração mínima do Model Armor para um determinado projeto.


import (
	"context"
	"fmt"
	"io"

	modelarmor "cloud.google.com/go/modelarmor/apiv1"
	modelarmorpb "cloud.google.com/go/modelarmor/apiv1/modelarmorpb"
)

// getProjectFloorSettings gets details of a single floor setting of a project.
//
// This method retrieves the details of a single floor setting of a project.
//
// w io.Writer: The writer to use for logging.
// projectID string: The ID of the project.
func getProjectFloorSettings(w io.Writer, projectID string) error {
	ctx := context.Background()

	// Create the Model Armor client.
	client, err := modelarmor.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("failed to create client: %w", err)
	}
	defer client.Close()

	floorSettingsName := fmt.Sprintf("projects/%s/locations/global/floorSetting", projectID)

	// Get the project floor setting.
	req := &modelarmorpb.GetFloorSettingRequest{
		Name: floorSettingsName,
	}

	response, err := client.GetFloorSetting(ctx, req)
	if err != nil {
		return fmt.Errorf("failed to get floor setting: %w", err)
	}

	// Print the retrieved floor setting using fmt.Fprintf with the io.Writer.
	fmt.Fprintf(w, "Retrieved floor setting: %v\n", response)

	return nil
}

Confira a configuração mínima do Model Armor para uma determinada pasta.


import (
	"context"
	"fmt"
	"io"

	modelarmor "cloud.google.com/go/modelarmor/apiv1"
	modelarmorpb "cloud.google.com/go/modelarmor/apiv1/modelarmorpb"
)

// getFolderFloorSettings gets details of a single floor setting of a folder.
//
// This method retrieves the details of a single floor setting of a folder.
//
// w io.Writer: The writer to use for logging.
// folderID string: The ID of the folder.
func getFolderFloorSettings(w io.Writer, folderID string) error {
	ctx := context.Background()

	// Create the Model Armor client.
	client, err := modelarmor.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("failed to create client: %w", err)
	}
	defer client.Close()

	// Prepare folder floor setting path/name
	floorSettingsName := fmt.Sprintf("folders/%s/locations/global/floorSetting", folderID)

	// Get the folder floor setting.
	req := &modelarmorpb.GetFloorSettingRequest{
		Name: floorSettingsName,
	}

	response, err := client.GetFloorSetting(ctx, req)
	if err != nil {
		return fmt.Errorf("failed to get floor setting: %w", err)
	}

	// Print the retrieved floor setting using fmt.Fprintf with the io.Writer.
	fmt.Fprintf(w, "Retrieved folder floor setting: %v\n", response)

	return nil
}

Confira a configuração mínima do Model Armor para uma determinada organização.


import (
	"context"
	"fmt"
	"io"

	modelarmor "cloud.google.com/go/modelarmor/apiv1"
	modelarmorpb "cloud.google.com/go/modelarmor/apiv1/modelarmorpb"
)

// getOrganizationFloorSettings gets details of a single floor setting of an organization.
//
// This method retrieves the details of a single floor setting of an organization.
//
// w io.Writer: The writer to use for logging.
// organizationID string: The ID of the organization.
func getOrganizationFloorSettings(w io.Writer, organizationID string) error {
	ctx := context.Background()

	// Create the Model Armor client.
	client, err := modelarmor.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("failed to create client: %w", err)
	}
	defer client.Close()

	floorSettingsName := fmt.Sprintf("organizations/%s/locations/global/floorSetting", organizationID)

	// Get the organization floor setting.
	req := &modelarmorpb.GetFloorSettingRequest{
		Name: floorSettingsName,
	}

	response, err := client.GetFloorSetting(ctx, req)
	if err != nil {
		return fmt.Errorf("failed to get floor setting: %w", err)
	}

	// Print the retrieved floor setting using fmt.Fprintf with the io.Writer.
	fmt.Fprintf(w, "Retrieved org floor setting: %v\n", response)

	return nil
}

Java

Para executar esse código, primeiro configure um ambiente de desenvolvimento Java e instale o SDK do Model Armor para Java.

Confira a configuração mínima do Model Armor para um determinado projeto.


import com.google.cloud.modelarmor.v1.FloorSetting;
import com.google.cloud.modelarmor.v1.FloorSettingName;
import com.google.cloud.modelarmor.v1.GetFloorSettingRequest;
import com.google.cloud.modelarmor.v1.ModelArmorClient;
import java.io.IOException;

public class GetProjectFloorSetting {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";

    getProjectFloorSetting(projectId);
  }

  public static FloorSetting getProjectFloorSetting(String projectId) throws IOException {

    // Initialize client that will be used to send requests. This client only
    // needs to be created once, and can be reused for multiple requests.
    try (ModelArmorClient client = ModelArmorClient.create()) {
      String name = FloorSettingName.of(projectId, "global").toString();

      GetFloorSettingRequest request = GetFloorSettingRequest.newBuilder().setName(name).build();

      FloorSetting floorSetting = client.getFloorSetting(request);
      System.out.println("Fetched floor setting for project: " + projectId);

      return floorSetting;
    }
  }
}

Confira a configuração mínima do Model Armor para uma determinada pasta.


import com.google.cloud.modelarmor.v1.FloorSetting;
import com.google.cloud.modelarmor.v1.FloorSettingName;
import com.google.cloud.modelarmor.v1.GetFloorSettingRequest;
import com.google.cloud.modelarmor.v1.ModelArmorClient;
import java.io.IOException;

public class GetFolderFloorSetting {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String folderId = "your-folder-id";

    getFolderFloorSetting(folderId);
  }

  public static FloorSetting getFolderFloorSetting(String folderId) throws IOException {

    // Initialize client that will be used to send requests. This client only
    // needs to be created once, and can be reused for multiple requests.
    try (ModelArmorClient client = ModelArmorClient.create()) {
      String name = FloorSettingName.ofFolderLocationName(folderId, "global").toString();

      GetFloorSettingRequest request = GetFloorSettingRequest.newBuilder().setName(name).build();

      FloorSetting floorSetting = client.getFloorSetting(request);
      System.out.println("Fetched floor setting for folder: " + folderId);

      return floorSetting;
    }
  }
}

Confira a configuração mínima do Model Armor para uma determinada organização.


import com.google.cloud.modelarmor.v1.FloorSetting;
import com.google.cloud.modelarmor.v1.FloorSettingName;
import com.google.cloud.modelarmor.v1.GetFloorSettingRequest;
import com.google.cloud.modelarmor.v1.ModelArmorClient;
import java.io.IOException;

public class GetOrganizationFloorSetting {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String organizationId = "your-organization-id";

    getOrganizationFloorSetting(organizationId);
  }

  public static FloorSetting getOrganizationFloorSetting(String organizationId) throws IOException {

    // Initialize client that will be used to send requests. This client only
    // needs to be created once, and can be reused for multiple requests.
    try (ModelArmorClient client = ModelArmorClient.create()) {
      String name = FloorSettingName.ofOrganizationLocationName(organizationId, "global")
          .toString();

      GetFloorSettingRequest request = GetFloorSettingRequest.newBuilder().setName(name).build();

      FloorSetting floorSetting = client.getFloorSetting(request);
      System.out.println("Fetched floor setting for organization: " + organizationId);

      return floorSetting;
    }
  }
}

Node.js

Para executar esse código, primeiro configure um ambiente de desenvolvimento do Node.js e instale o SDK do Model Armor para Node.js.

Confira a configuração mínima do Model Armor para um determinado projeto.

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'your-project-id';

const name = `projects/${projectId}/locations/global/floorSetting`;

// Imports the Modelarmor library
const {ModelArmorClient} = require('@google-cloud/modelarmor').v1;

// Instantiates a client
const modelarmorClient = new ModelArmorClient();

async function getProjectFloorSettings() {
  // Construct request
  const request = {
    name,
  };

  // Run request
  const [response] = await modelarmorClient.getFloorSetting(request);
  return response;
}

return await getProjectFloorSettings();

Confira a configuração mínima do Model Armor para uma determinada pasta.

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const folderId = 'your-folder-id';

const name = `folders/${folderId}/locations/global/floorSetting`;

// Imports the Modelarmor library
const {ModelArmorClient} = require('@google-cloud/modelarmor').v1;

// Instantiates a client
const modelarmorClient = new ModelArmorClient();

async function getFolderFloorSettings() {
  // Construct request
  const request = {
    name,
  };

  const [response] = await modelarmorClient.getFloorSetting(request);
  return response;
}

return await getFolderFloorSettings();

Confira a configuração mínima do Model Armor para uma determinada organização.

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const organizationId = 'your-organization-id';
const name = `organizations/${organizationId}/locations/global/floorSetting`;

// Imports the Modelarmor library
const {ModelArmorClient} = require('@google-cloud/modelarmor').v1;

// Instantiates a client
const modelarmorClient = new ModelArmorClient();

async function getOrganizationFloorSettings() {
  // Construct request
  const request = {
    name,
  };

  // Run request
  const [response] = await modelarmorClient.getFloorSetting(request);
  return response;
}

return await getOrganizationFloorSettings();

PHP

Para executar esse código, primeiro configure um ambiente de desenvolvimento PHP e instale o SDK do Model Armor para PHP.

Confira a configuração mínima do Model Armor para um determinado projeto.

use Google\Cloud\ModelArmor\V1\Client\ModelArmorClient;
use Google\Cloud\ModelArmor\V1\GetFloorSettingRequest;

/**
 * Gets the floor settings for a given project.
 *
 * @param string $projectId The project Id for which the floor settings is to be retrieved.
 *
 */
function get_project_floor_settings(string $projectId): void
{
    $client = new ModelArmorClient();

    $floorSettingsName = sprintf('projects/%s/locations/global/floorSetting', $projectId);

    $response = $client->getFloorSetting((new GetFloorSettingRequest())->setName($floorSettingsName));

    printf("Floor settings retrieved successfully: %s\n", $response->serializeToJsonString());
}

Confira a configuração mínima do Model Armor para uma determinada pasta.

use Google\Cloud\ModelArmor\V1\Client\ModelArmorClient;
use Google\Cloud\ModelArmor\V1\GetFloorSettingRequest;

/**
 * Gets the floor settings for a given folder.
 *
 * @param string $folderId The folder Id for which the floor settings is to be retrieved.
 *
 */
function get_folder_floor_settings(string $folderId): void
{
    $client = new ModelArmorClient();

    $floorSettingsName = sprintf('folders/%s/locations/global/floorSetting', $folderId);

    $response = $client->getFloorSetting((new GetFloorSettingRequest())->setName($floorSettingsName));

    printf("Floor settings retrieved successfully: %s\n", $response->serializeToJsonString());
}

Confira a configuração mínima do Model Armor para uma determinada organização.

use Google\Cloud\ModelArmor\V1\Client\ModelArmorClient;
use Google\Cloud\ModelArmor\V1\GetFloorSettingRequest;

/**
 * Gets the floor settings for a given organization.
 *
 * @param string $organizationId The organization Id for which the floor settings is to be retrieved.
 *
 */
function get_organization_floor_settings(string $organizationId): void
{
    $client = new ModelArmorClient();

    $floorSettingsName = sprintf('organizations/%s/locations/global/floorSetting', $organizationId);

    $response = $client->getFloorSetting((new GetFloorSettingRequest())->setName($floorSettingsName));

    printf("Floor settings retrieved successfully: %s\n", $response->serializeToJsonString());
}

Python

Para executar esse código, primeiro configure um ambiente de desenvolvimento Python e instale o SDK do Model Armor para Python.

Confira a configuração mínima do Model Armor para um determinado projeto.


from google.cloud import modelarmor_v1

# Create the Model Armor client.
client = modelarmor_v1.ModelArmorClient(transport="rest")

# TODO(Developer): Uncomment below variable.
# project_id = "YOUR_PROJECT_ID"

floor_settings_name = f"projects/{project_id}/locations/global/floorSetting"

# Get the project floor setting.
response = client.get_floor_setting(
    request=modelarmor_v1.GetFloorSettingRequest(name=floor_settings_name)
)

# Print the retrieved floor setting.
print(response)

Confira a configuração mínima do Model Armor para uma determinada pasta.


from google.cloud import modelarmor_v1

# Create the Model Armor client.
client = modelarmor_v1.ModelArmorClient(transport="rest")

# TODO(Developer): Uncomment below variable.
# folder_id = "YOUR_FOLDER_ID"

# Prepare folder floor setting path/name
floor_settings_name = f"folders/{folder_id}/locations/global/floorSetting"

# Get the folder floor setting.
response = client.get_floor_setting(
    request=modelarmor_v1.GetFloorSettingRequest(name=floor_settings_name)
)

# Print the retrieved floor setting.
print(response)

Confira a configuração mínima do Model Armor para uma determinada organização.


from google.cloud import modelarmor_v1

# Create the Model Armor client.
client = modelarmor_v1.ModelArmorClient(transport="rest")

# TODO(Developer): Uncomment below variable.
# organization_id = "YOUR_ORGANIZATION_ID"

floor_settings_name = (
    f"organizations/{organization_id}/locations/global/floorSetting"
)

# Get the organization floor setting.
response = client.get_floor_setting(
    request=modelarmor_v1.GetFloorSettingRequest(name=floor_settings_name)
)

# Print the retrieved floor setting.
print(response)

Atualizar as configurações do Model Armor Floor

Atualize as configurações mínimas do Model Armor para mudar os requisitos mínimos dos modelos e refletir mudanças nas políticas de segurança, corrigir configurações incorretas ou resolver conflitos entre as configurações mínimas.

Execute o comando a seguir para atualizar as configurações mínimas do Model Armor.

Console

No console do Google Cloud , acesse a página Model Armor.

Acessar o Model Armor
Verifique se você está visualizando o projeto em que ativou o Model Armor.
Na página Model Armor, acesse a guia Configurações de restrição e clique em Configurar restrições.
Atualize os campos obrigatórios e clique em Salvar configurações de piso.

gcloud

   gcloud model-armor floorsettings update --full-uri=<full-uri-of-the-floorsetting>

Exemplo de comando:

       gcloud model-armor floorsettings update \
           --malicious-uri-filter-settings-enforcement=ENABLED \
           --pi-and-jailbreak-filter-settings-enforcement=DISABLED \
           --pi-and-jailbreak-filter-settings-confidence-level=LOW_AND_ABOVE \
           --basic-config-filter-enforcement=ENABLED \
           --add-rai-settings-filters='[{"confidenceLevel": "low_and_above", "filterType": "HARASSMENT"}, {"confidenceLevel": "high", "filterType": "SEXUALLY_EXPLICIT"}]'
           --full-uri='folders/FOLDER_ID/locations/global/floorSetting' \
           --enable-floor-setting-enforcement=true

Para configurar as opções de piso com a detecção multilíngue ativada, execute o seguinte comando:

    gcloud model-armor floorsettings update \
        --full-uri=projects/PROJECT_ID/locations/global/floorSetting \
        --enable-multi-language-detection

Substitua:

PROJECT_ID: o ID do projeto para as configurações de limite mínimo.
FOLDER_ID: o ID da pasta para as configurações de valor mínimo.

REST

Atualiza a configuração de limite do Model Armor para um determinado projeto.

curl -X PATCH
  -d '{"filterConfig" :{"piAndJailbreakFilterSettings": { "filterEnforcement": "ENABLED"}, "maliciousUriFilterSettings": { "filterEnforcement": "ENABLED" }, "rai_settings":{"rai_filters":{"filter_type":"DANGEROUS", "confidence_level":"LOW_AND_ABOVE" }, \
  "rai_filters":{"filter_type":"HATE_SPEECH", "confidence_level":"LOW_AND_ABOVE" }, "rai_filters":{"filter_type":"HARASSMENT", "confidence_level":"LOW_AND_ABOVE" }, "rai_filters":{"filter_type":"SEXUALLY_EXPLICIT", "confidence_level":"LOW_AND_ABOVE" }}},"enableFloorSettingEnforcement":"true"}' \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $(gcloud auth print-access-token) \
  "https://modelarmor.googleapis.com/v1/projects/PROJECT_ID/locations/global/floorSetting"

Atualiza a configuração do Model Armor Floor para uma determinada pasta.

curl -X PATCH \
  -d '{"filterConfig" :{"piAndJailbreakFilterSettings": { "filterEnforcement": "ENABLED"}, "maliciousUriFilterSettings": {"filterEnforcement": "ENABLED" }},"enableFloorSettingEnforcement":"true"}' \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  "https://modelarmor.googleapis.com/v1/folders/FOLDER_ID/locations/global/floorSetting"

Atualize a configuração de limite do Model Armor para uma determinada organização.

curl -X PATCH \
  -d '{"filterConfig" :{"piAndJailbreakFilterSettings": { "filterEnforcement": "ENABLED"}, "maliciousUriFilterSettings": {
      "filterEnforcement": "ENABLED" }},"enableFloorSettingEnforcement":"true"}' \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
      "https://modelarmor.googleapis.com/v1/organizations/ORGANIZATION_ID/locations/global/floorSetting"

Substitua:

PROJECT_ID: o ID do projeto para as configurações de limite mínimo.
FOLDER_ID: o ID da pasta para as configurações de valor mínimo.
ORGANIZATION_ID: o ID da organização para as configurações de preço mínimo.

O comando de atualização retorna a seguinte resposta:

{
"name": "projects/PROJECT_ID/locations/global/floorSetting",
"updateTime": "2024-12-19T15:36:21.318191Z",
"filterConfig": {
"piAndJailbreakFilterSettings": {
  "filterEnforcement": "ENABLED"
},
"maliciousUriFilterSettings": {
"filterEnforcement": "ENABLED"
}
}
}

C#

Para executar esse código, primeiro configure um ambiente de desenvolvimento em C# e instale o SDK do Model Armor para C#.

Atualiza a configuração de limite do Model Armor para um determinado projeto.

using Google.Cloud.ModelArmor.V1;
using System;

public class UpdateProjectFloorSettings
{
    public FloorSetting UpdateProjectFloorSetting(string projectId)
    {
        // Create the client
        ModelArmorClient client = ModelArmorClient.Create();

        // Construct the floor settings name
        string floorSettingsName = $"projects/{projectId}/locations/global/floorSetting";

        // Build the floor settings with your preferred filters
        // For more details on filters, please refer to the following doc:
        // https://cloud.google.com/security-command-center/docs/key-concepts-model-armor#ma-filters
        var raiFilter = new RaiFilterSettings.Types.RaiFilter
        {
            FilterType = RaiFilterType.HateSpeech,
            ConfidenceLevel = DetectionConfidenceLevel.High,
        };

        var raiFilterSettings = new RaiFilterSettings();
        raiFilterSettings.RaiFilters.Add(raiFilter);

        var filterConfig = new FilterConfig { RaiSettings = raiFilterSettings };

        var floorSetting = new FloorSetting
        {
            Name = floorSettingsName,
            FilterConfig = filterConfig,
            EnableFloorSettingEnforcement = true,
        };

        // Create the update request
        var updateRequest = new UpdateFloorSettingRequest { FloorSetting = floorSetting };

        // Update the floor settings
        FloorSetting response = client.UpdateFloorSetting(updateRequest);

        Console.WriteLine($"Floor setting updated: {response.Name}");

        return response;
    }
}

Atualiza a configuração do Model Armor Floor para uma determinada pasta.

using Google.Cloud.ModelArmor.V1;
using System;

public class UpdateFolderFloorSettings
{
    public FloorSetting UpdateFolderFloorSetting(string folderId)
    {
        // Create the client
        ModelArmorClient client = ModelArmorClient.Create();

        // Construct the floor settings name
        string floorSettingsName = $"folders/{folderId}/locations/global/floorSetting";

        // Build the floor settings with your preferred filters
        // For more details on filters, please refer to the following doc:
        // https://cloud.google.com/security-command-center/docs/key-concepts-model-armor#ma-filters
        var raiFilter = new RaiFilterSettings.Types.RaiFilter
        {
            FilterType = RaiFilterType.HateSpeech,
            ConfidenceLevel = DetectionConfidenceLevel.High,
        };

        var raiFilterSettings = new RaiFilterSettings();
        raiFilterSettings.RaiFilters.Add(raiFilter);

        var filterConfig = new FilterConfig { RaiSettings = raiFilterSettings };

        var floorSetting = new FloorSetting
        {
            Name = floorSettingsName,
            FilterConfig = filterConfig,
            EnableFloorSettingEnforcement = true,
        };

        // Create the update request
        var updateRequest = new UpdateFloorSettingRequest { FloorSetting = floorSetting };

        // Update the floor settings
        FloorSetting response = client.UpdateFloorSetting(updateRequest);

        Console.WriteLine($"Floor setting updated: {response.Name}");

        return response;
    }
}

Atualize a configuração de limite do Model Armor para uma determinada organização.

using Google.Cloud.ModelArmor.V1;
using System;

public class UpdateOrganizationFloorSettings
{
    public FloorSetting UpdateOrganizationFloorSetting(string organizationId)
    {
        // Create the client
        ModelArmorClient client = ModelArmorClient.Create();

        // Construct the floor settings name
        string floorSettingsName = $"organizations/{organizationId}/locations/global/floorSetting";

        // Build the floor settings with your preferred filters
        // For more details on filters, please refer to the following doc:
        // https://cloud.google.com/security-command-center/docs/key-concepts-model-armor#ma-filters
        var raiFilter = new RaiFilterSettings.Types.RaiFilter
        {
            FilterType = RaiFilterType.HateSpeech,
            ConfidenceLevel = DetectionConfidenceLevel.High,
        };

        var raiFilterSettings = new RaiFilterSettings();
        raiFilterSettings.RaiFilters.Add(raiFilter);

        var filterConfig = new FilterConfig { RaiSettings = raiFilterSettings };

        var floorSetting = new FloorSetting
        {
            Name = floorSettingsName,
            FilterConfig = filterConfig,
            EnableFloorSettingEnforcement = true,
        };

        // Create the update request
        var updateRequest = new UpdateFloorSettingRequest { FloorSetting = floorSetting };

        // Update the floor settings
        FloorSetting response = client.UpdateFloorSetting(updateRequest);

        Console.WriteLine($"Floor setting updated: {response.Name}");

        return response;
    }
}

Go

Para executar esse código, primeiro configure um ambiente de desenvolvimento do Go e instale o SDK do Model Armor para Go.

Atualiza a configuração de limite do Model Armor para um determinado projeto.


import (
	"context"
	"fmt"
	"io"

	modelarmor "cloud.google.com/go/modelarmor/apiv1"
	modelarmorpb "cloud.google.com/go/modelarmor/apiv1/modelarmorpb"
)

// updateProjectFloorSettings updates the floor settings of a project.
//
// This method updates the floor settings of a project.
//
// w io.Writer: The writer to use for logging.
// projectID string: The ID of the project.
func updateProjectFloorSettings(w io.Writer, projectID string) error {
	ctx := context.Background()

	// Create the Model Armor client.
	client, err := modelarmor.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("failed to create client: %w", err)
	}
	defer client.Close()

	// Prepare project floor setting path/name
	floorSettingsName := fmt.Sprintf("projects/%s/locations/global/floorSetting", projectID)

	// Update the project floor setting
	// For more details on filters, please refer to the following doc:
	// [https://cloud.google.com/security-command-center/docs/key-concepts-model-armor#ma-filters](https://cloud.google.com/security-command-center/docs/key-concepts-model-armor#ma-filters)
	enableEnforcement := true
	req := &modelarmorpb.UpdateFloorSettingRequest{
		FloorSetting: &modelarmorpb.FloorSetting{
			Name: floorSettingsName,
			FilterConfig: &modelarmorpb.FilterConfig{
				RaiSettings: &modelarmorpb.RaiFilterSettings{
					RaiFilters: []*modelarmorpb.RaiFilterSettings_RaiFilter{
						{
							FilterType:      modelarmorpb.RaiFilterType_HATE_SPEECH,
							ConfidenceLevel: modelarmorpb.DetectionConfidenceLevel_HIGH,
						},
					},
				},
			},
			EnableFloorSettingEnforcement: &enableEnforcement,
		},
	}

	response, err := client.UpdateFloorSetting(ctx, req)
	if err != nil {
		return fmt.Errorf("failed to update floor setting: %w", err)
	}

	// Print the updated config
	fmt.Fprintf(w, "Updated project floor setting: %+v\n", response)

	return nil
}

Atualiza a configuração do Model Armor Floor para uma determinada pasta.


import (
	"context"
	"fmt"
	"io"

	modelarmor "cloud.google.com/go/modelarmor/apiv1"
	modelarmorpb "cloud.google.com/go/modelarmor/apiv1/modelarmorpb"
)

// updateFolderFloorSettings updates floor settings of a folder.
//
// This method updates the floor settings of a folder.
//
// w io.Writer: The writer to use for logging.
// folderID string: The ID of the folder.
func updateFolderFloorSettings(w io.Writer, folderID string) error {
	ctx := context.Background()

	// Create the Model Armor client.
	client, err := modelarmor.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("failed to create client: %w", err)
	}
	defer client.Close()

	// Prepare folder floor settings path/name
	floorSettingsName := fmt.Sprintf("folders/%s/locations/global/floorSetting", folderID)

	// Prepare the floor setting update
	enableEnforcement := true
	floorSetting := &modelarmorpb.FloorSetting{
		Name: floorSettingsName,
		FilterConfig: &modelarmorpb.FilterConfig{
			RaiSettings: &modelarmorpb.RaiFilterSettings{
				RaiFilters: []*modelarmorpb.RaiFilterSettings_RaiFilter{
					{
						FilterType:      modelarmorpb.RaiFilterType_HATE_SPEECH,
						ConfidenceLevel: modelarmorpb.DetectionConfidenceLevel_HIGH,
					},
				},
			},
		},
		EnableFloorSettingEnforcement: &enableEnforcement,
	}

	// Prepare request for updating the floor setting.
	req := &modelarmorpb.UpdateFloorSettingRequest{
		FloorSetting: floorSetting,
	}

	// Update the floor setting.
	response, err := client.UpdateFloorSetting(ctx, req)
	if err != nil {
		return fmt.Errorf("failed to update floor setting: %w", err)
	}

	// Print the updated config
	fmt.Fprintf(w, "Updated folder floor setting: %v\n", response)

	return nil

}

Atualize a configuração de limite do Model Armor para uma determinada organização.


import (
	"context"
	"fmt"
	"io"

	modelarmor "cloud.google.com/go/modelarmor/apiv1"
	modelarmorpb "cloud.google.com/go/modelarmor/apiv1/modelarmorpb"
)

// updateOrganizationFloorSettings updates floor settings of an organization.
//
// This method updates the floor settings of an organization.
//
// w io.Writer: The writer to use for logging.
// organizationID string: The ID of the organization.
func updateOrganizationFloorSettings(w io.Writer, organizationID string) error {
	ctx := context.Background()

	// Create the Model Armor client.
	client, err := modelarmor.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("failed to create client: %w", err)
	}
	defer client.Close()

	// Prepare organization floor setting path/name
	floorSettingsName := fmt.Sprintf("organizations/%s/locations/global/floorSetting", organizationID)

	// Update the organization floor setting
	// For more details on filters, please refer to the following doc:
	// [https://cloud.google.com/security-command-center/docs/key-concepts-model-armor#ma-filters](https://cloud.google.com/security-command-center/docs/key-concepts-model-armor#ma-filters)
	enableEnforcement := true
	req := &modelarmorpb.UpdateFloorSettingRequest{
		FloorSetting: &modelarmorpb.FloorSetting{
			Name: floorSettingsName,
			FilterConfig: &modelarmorpb.FilterConfig{
				RaiSettings: &modelarmorpb.RaiFilterSettings{
					RaiFilters: []*modelarmorpb.RaiFilterSettings_RaiFilter{
						{
							FilterType:      modelarmorpb.RaiFilterType_HATE_SPEECH,
							ConfidenceLevel: modelarmorpb.DetectionConfidenceLevel_HIGH,
						},
					},
				},
			},
			EnableFloorSettingEnforcement: &enableEnforcement,
		},
	}

	response, err := client.UpdateFloorSetting(ctx, req)
	if err != nil {
		return fmt.Errorf("failed to update floor setting: %w", err)
	}

	// Print the updated config
	fmt.Fprintf(w, "Updated org floor setting: %+v\n", response)

Java

Para executar esse código, primeiro configure um ambiente de desenvolvimento Java e instale o SDK do Model Armor para Java.

Atualiza a configuração de limite do Model Armor para um determinado projeto.


import com.google.cloud.modelarmor.v1.DetectionConfidenceLevel;
import com.google.cloud.modelarmor.v1.FilterConfig;
import com.google.cloud.modelarmor.v1.FloorSetting;
import com.google.cloud.modelarmor.v1.FloorSettingName;
import com.google.cloud.modelarmor.v1.ModelArmorClient;
import com.google.cloud.modelarmor.v1.RaiFilterSettings;
import com.google.cloud.modelarmor.v1.RaiFilterSettings.RaiFilter;
import com.google.cloud.modelarmor.v1.RaiFilterType;
import com.google.cloud.modelarmor.v1.UpdateFloorSettingRequest;
import com.google.protobuf.FieldMask;
import java.io.IOException;
import java.util.List;

public class UpdateProjectFloorSetting {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";

    updateProjectFloorSetting(projectId);
  }

  public static FloorSetting updateProjectFloorSetting(String projectId)
      throws IOException {

    // Initialize client that will be used to send requests. This client only
    // needs to be created once, and can be reused for multiple requests.
    try (ModelArmorClient client = ModelArmorClient.create()) {
      String name = FloorSettingName.of(projectId, "global").toString();

      // For more details on filters, please refer to the following doc:
      // https://cloud.google.com/security-command-center/docs/key-concepts-model-armor#ma-filters
      RaiFilterSettings raiFilterSettings =
          RaiFilterSettings.newBuilder()
              .addAllRaiFilters(
                  List.of(
                      RaiFilter.newBuilder()
                          .setFilterType(RaiFilterType.HARASSMENT)
                          .setConfidenceLevel(DetectionConfidenceLevel.LOW_AND_ABOVE)
                          .build(),
                      RaiFilter.newBuilder()
                          .setFilterType(RaiFilterType.SEXUALLY_EXPLICIT)
                          .setConfidenceLevel(DetectionConfidenceLevel.HIGH)
                          .build()))
              .build();

      FilterConfig modelArmorFilter = FilterConfig.newBuilder()
          .setRaiSettings(raiFilterSettings)
          .build();

      // Create a field mask to specify which fields to update.
      // Ref: https://protobuf.dev/reference/protobuf/google.protobuf/#field-mask
      FieldMask updateMask = FieldMask.newBuilder().addPaths("filter_config.rai_settings").build();

      FloorSetting floorSetting = FloorSetting.newBuilder()
          .setName(name)
          .setFilterConfig(modelArmorFilter)
          .setEnableFloorSettingEnforcement(true)
          .build();

      UpdateFloorSettingRequest request = UpdateFloorSettingRequest.newBuilder()
          .setFloorSetting(floorSetting)
          .setUpdateMask(updateMask)
          .build();

      FloorSetting updatedFloorSetting = client.updateFloorSetting(request);
      System.out.println("Updated floor setting for project: " + projectId);

      return updatedFloorSetting;
    }
  }
}

Atualiza a configuração do Model Armor Floor para uma determinada pasta.


import com.google.cloud.modelarmor.v1.DetectionConfidenceLevel;
import com.google.cloud.modelarmor.v1.FilterConfig;
import com.google.cloud.modelarmor.v1.FloorSetting;
import com.google.cloud.modelarmor.v1.FloorSettingName;
import com.google.cloud.modelarmor.v1.ModelArmorClient;
import com.google.cloud.modelarmor.v1.RaiFilterSettings;
import com.google.cloud.modelarmor.v1.RaiFilterSettings.RaiFilter;
import com.google.cloud.modelarmor.v1.RaiFilterType;
import com.google.cloud.modelarmor.v1.UpdateFloorSettingRequest;
import com.google.protobuf.FieldMask;
import java.io.IOException;
import java.util.List;

public class UpdateFolderFloorSetting {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String folderId = "your-folder-id";

    updateFolderFloorSetting(folderId);
  }

  public static FloorSetting updateFolderFloorSetting(String folderId)
      throws IOException {

    // Initialize client that will be used to send requests. This client only
    // needs to be created once, and can be reused for multiple requests.
    try (ModelArmorClient client = ModelArmorClient.create()) {
      String name = FloorSettingName.ofFolderLocationName(folderId, "global").toString();

      // For more details on filters, please refer to the following doc:
      // https://cloud.google.com/security-command-center/docs/key-concepts-model-armor#ma-filters
      RaiFilterSettings raiFilterSettings =
          RaiFilterSettings.newBuilder()
              .addAllRaiFilters(
                  List.of(
                      RaiFilter.newBuilder()
                          .setFilterType(RaiFilterType.HARASSMENT)
                          .setConfidenceLevel(DetectionConfidenceLevel.LOW_AND_ABOVE)
                          .build(),
                      RaiFilter.newBuilder()
                          .setFilterType(RaiFilterType.SEXUALLY_EXPLICIT)
                          .setConfidenceLevel(DetectionConfidenceLevel.HIGH)
                          .build()))
              .build();

      FilterConfig modelArmorFilter = FilterConfig.newBuilder()
          .setRaiSettings(raiFilterSettings)
          .build();

      // Create a field mask to specify which fields to update.
      // Ref: https://protobuf.dev/reference/protobuf/google.protobuf/#field-mask
      FieldMask updateMask = FieldMask.newBuilder().addPaths("filter_config.rai_settings").build();

      FloorSetting floorSetting = FloorSetting.newBuilder()
          .setName(name)
          .setFilterConfig(modelArmorFilter)
          .setEnableFloorSettingEnforcement(true)
          .build();

      UpdateFloorSettingRequest request = UpdateFloorSettingRequest.newBuilder()
          .setFloorSetting(floorSetting)
          .setUpdateMask(updateMask)
          .build();

      FloorSetting updatedFloorSetting = client.updateFloorSetting(request);
      System.out.println("Updated floor setting for folder: " + folderId);

      return updatedFloorSetting;
    }
  }
}

Atualize a configuração de limite do Model Armor para uma determinada organização.


import com.google.cloud.modelarmor.v1.DetectionConfidenceLevel;
import com.google.cloud.modelarmor.v1.FilterConfig;
import com.google.cloud.modelarmor.v1.FloorSetting;
import com.google.cloud.modelarmor.v1.FloorSettingName;
import com.google.cloud.modelarmor.v1.ModelArmorClient;
import com.google.cloud.modelarmor.v1.RaiFilterSettings;
import com.google.cloud.modelarmor.v1.RaiFilterSettings.RaiFilter;
import com.google.cloud.modelarmor.v1.RaiFilterType;
import com.google.cloud.modelarmor.v1.UpdateFloorSettingRequest;
import com.google.protobuf.FieldMask;
import java.io.IOException;
import java.util.List;

public class UpdateOrganizationsFloorSetting {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String organizationId = "your-organization-id";

    updateOrganizationFloorSetting(organizationId);
  }

  public static FloorSetting updateOrganizationFloorSetting(String organizationId)
      throws IOException {

    // Initialize client that will be used to send requests. This client only
    // needs to be created once, and can be reused for multiple requests.
    try (ModelArmorClient client = ModelArmorClient.create()) {
      String name = FloorSettingName.ofOrganizationLocationName(organizationId, "global")
          .toString();

      // For more details on filters, please refer to the following doc:
      // https://cloud.google.com/security-command-center/docs/key-concepts-model-armor#ma-filters
      RaiFilterSettings raiFilterSettings =
          RaiFilterSettings.newBuilder()
              .addAllRaiFilters(
                  List.of(
                      RaiFilter.newBuilder()
                          .setFilterType(RaiFilterType.HARASSMENT)
                          .setConfidenceLevel(DetectionConfidenceLevel.LOW_AND_ABOVE)
                          .build(),
                      RaiFilter.newBuilder()
                          .setFilterType(RaiFilterType.SEXUALLY_EXPLICIT)
                          .setConfidenceLevel(DetectionConfidenceLevel.HIGH)
                          .build()))
              .build();

      FilterConfig modelArmorFilter = FilterConfig.newBuilder()
          .setRaiSettings(raiFilterSettings)
          .build();

      // Create a field mask to specify which fields to update.
      // Ref: https://protobuf.dev/reference/protobuf/google.protobuf/#field-mask
      FieldMask updateMask = FieldMask.newBuilder()
          .addPaths("filter_config.rai_settings")
          .build();

      FloorSetting floorSetting = FloorSetting.newBuilder()
          .setName(name)
          .setFilterConfig(modelArmorFilter)
          .setEnableFloorSettingEnforcement(true)
          .build();

      UpdateFloorSettingRequest request = UpdateFloorSettingRequest.newBuilder()
          .setFloorSetting(floorSetting)
          .setUpdateMask(updateMask)
          .build();

      FloorSetting updatedFloorSetting = client.updateFloorSetting(request);
      System.out.println("Updated floor setting for organization: " + organizationId);

      return updatedFloorSetting;
    }
  }
}

Node.js

Para executar esse código, primeiro configure um ambiente de desenvolvimento do Node.js e instale o SDK do Model Armor para Node.js.

Atualiza a configuração de limite do Model Armor para um determinado projeto.

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'your-project-id';

const modelarmor = require('@google-cloud/modelarmor');
const {ModelArmorClient} = modelarmor.v1;
const {protos} = modelarmor;

// Initiate client
const client = new ModelArmorClient();

async function updateProjectFloorSettings() {
  const floorSettingsName = `projects/${projectId}/locations/global/floorSetting`;

  // Build the floor settings with your preferred filters
  // For more details on filters, please refer to the following doc:
  // https://cloud.google.com/security-command-center/docs/key-concepts-model-armor#ma-filters
  const floorSetting = {
    name: floorSettingsName,
    filterConfig: {
      raiSettings: {
        raiFilters: [
          {
            filterType:
              protos.google.cloud.modelarmor.v1.RaiFilterType.HARASSMENT,
            confidenceLevel:
              protos.google.cloud.modelarmor.v1.DetectionConfidenceLevel
                .LOW_AND_ABOVE,
          },
          {
            filterType:
              protos.google.cloud.modelarmor.v1.RaiFilterType
                .SEXUALLY_EXPLICIT,
            confidenceLevel:
              protos.google.cloud.modelarmor.v1.DetectionConfidenceLevel
                .LOW_AND_ABOVE,
          },
        ],
      },
    },
    enableFloorSettingEnforcement: true,
  };

  const request = {
    floorSetting: floorSetting,
  };

  const [response] = await client.updateFloorSetting(request);
  return response;
}

return await updateProjectFloorSettings();

Atualiza a configuração do Model Armor Floor para uma determinada pasta.

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const folderId = 'your-folder-id';

// Imports the Model Armor library
const modelarmor = require('@google-cloud/modelarmor');
const {ModelArmorClient} = modelarmor.v1;
const {protos} = modelarmor;

// Instantiates a client
const client = new ModelArmorClient();

async function updateFolderFloorSettings() {
  const floorSettingsName = `folders/${folderId}/locations/global/floorSetting`;

  // Build the floor settings with your preferred filters
  // For more details on filters, please refer to the following doc:
  // https://cloud.google.com/security-command-center/docs/key-concepts-model-armor#ma-filters
  const floorSetting = {
    name: floorSettingsName,
    filterConfig: {
      raiSettings: {
        raiFilters: [
          {
            filterType:
              protos.google.cloud.modelarmor.v1.RaiFilterType.HARASSMENT,
            confidenceLevel:
              protos.google.cloud.modelarmor.v1.DetectionConfidenceLevel
                .LOW_AND_ABOVE,
          },
          {
            filterType:
              protos.google.cloud.modelarmor.v1.RaiFilterType
                .SEXUALLY_EXPLICIT,
            confidenceLevel:
              protos.google.cloud.modelarmor.v1.DetectionConfidenceLevel
                .LOW_AND_ABOVE,
          },
        ],
      },
    },
    enableFloorSettingEnforcement: true,
  };

  const request = {
    floorSetting: floorSetting,
  };

  const [response] = await client.updateFloorSetting(request);
  return response;
}

return await updateFolderFloorSettings();

Atualize a configuração de limite do Model Armor para uma determinada organização.

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const organizationId = 'your-organization-id';

const modelarmor = require('@google-cloud/modelarmor');
const {ModelArmorClient} = modelarmor.v1;
const {protos} = modelarmor;

const client = new ModelArmorClient();

async function updateOrganizationFloorSettings() {
  const floorSettingsName = `organizations/${organizationId}/locations/global/floorSetting`;

  // Build the floor settings with your preferred filters
  // For more details on filters, please refer to the following doc:
  // https://cloud.google.com/security-command-center/docs/key-concepts-model-armor#ma-filters
  const floorSetting = {
    name: floorSettingsName,
    filterConfig: {
      raiSettings: {
        raiFilters: [
          {
            filterType:
              protos.google.cloud.modelarmor.v1.RaiFilterType.HARASSMENT,
            confidenceLevel:
              protos.google.cloud.modelarmor.v1.DetectionConfidenceLevel
                .LOW_AND_ABOVE,
          },
          {
            filterType:
              protos.google.cloud.modelarmor.v1.RaiFilterType
                .SEXUALLY_EXPLICIT,
            confidenceLevel:
              protos.google.cloud.modelarmor.v1.DetectionConfidenceLevel
                .LOW_AND_ABOVE,
          },
        ],
      },
    },
    enableFloorSettingEnforcement: true,
  };

  const request = {
    floorSetting: floorSetting,
  };

  const [response] = await client.updateFloorSetting(request);
  return response;
}

return await updateOrganizationFloorSettings();

PHP

Para executar esse código, primeiro configure um ambiente de desenvolvimento PHP e instale o SDK do Model Armor para PHP.

Atualiza a configuração de limite do Model Armor para um determinado projeto.

use Google\Cloud\ModelArmor\V1\Client\ModelArmorClient;
use Google\Cloud\ModelArmor\V1\RaiFilterType;
use Google\Cloud\ModelArmor\V1\DetectionConfidenceLevel;
use Google\Cloud\ModelArmor\V1\UpdateFloorSettingRequest;
use Google\Cloud\ModelArmor\V1\FilterConfig;
use Google\Cloud\ModelArmor\V1\FloorSetting;
use Google\Cloud\ModelArmor\V1\RaiFilterSettings;
use Google\Cloud\ModelArmor\V1\RaiFilterSettings\RaiFilter;

/**
 * Updates the floor settings for a given project.
 *
 * @param string $projectId The project Id for which the floor settings is to be updated.
 *
 */
function update_project_floor_settings(string $projectId): void
{
    $client = new ModelArmorClient();

    $floorSettingsName = sprintf('projects/%s/locations/global/floorSetting', $projectId);

    // Build the floor settings with your preferred filters
    // For more details on filters, please refer to the following doc:
    // https://cloud.google.com/security-command-center/docs/key-concepts-model-armor#ma-filters

    $raiFilterSetting = (new RaiFilterSettings())
        ->setRaiFilters([
            (new RaiFilter())
                ->setFilterType(RaiFilterType::HATE_SPEECH)
                ->setConfidenceLevel(DetectionConfidenceLevel::HIGH)
        ]);

    $filterConfig = (new FilterConfig())->setRaiSettings($raiFilterSetting);
    $floorSetting = (new FloorSetting())
        ->setName($floorSettingsName)
        ->setFilterConfig($filterConfig)
        ->setEnableFloorSettingEnforcement(true);

    $updateRequest = (new UpdateFloorSettingRequest())->setFloorSetting($floorSetting);

    $response = $client->updateFloorSetting($updateRequest);

    printf("Floor setting updated: %s\n", $response->getName());
}

Atualiza a configuração do Model Armor Floor para uma determinada pasta.

use Google\Cloud\ModelArmor\V1\Client\ModelArmorClient;
use Google\Cloud\ModelArmor\V1\RaiFilterType;
use Google\Cloud\ModelArmor\V1\DetectionConfidenceLevel;
use Google\Cloud\ModelArmor\V1\UpdateFloorSettingRequest;
use Google\Cloud\ModelArmor\V1\FilterConfig;
use Google\Cloud\ModelArmor\V1\FloorSetting;
use Google\Cloud\ModelArmor\V1\RaiFilterSettings;
use Google\Cloud\ModelArmor\V1\RaiFilterSettings\RaiFilter;

/**
 * Updates the floor settings for a given folder.
 *
 * @param string $folderId The folder Id for which the floor settings is to be updated.
 *
 */
function update_folder_floor_settings(string $folderId): void
{
    $client = new ModelArmorClient();

    $floorSettingsName = sprintf('folders/%s/locations/global/floorSetting', $folderId);

    // Build the floor settings with your preferred filters
    // For more details on filters, please refer to the following doc:
    // https://cloud.google.com/security-command-center/docs/key-concepts-model-armor#ma-filters

    $raiFilterSetting = (new RaiFilterSettings())
        ->setRaiFilters([
            (new RaiFilter())
                ->setFilterType(RaiFilterType::HATE_SPEECH)
                ->setConfidenceLevel(DetectionConfidenceLevel::HIGH)
        ]);

    $filterConfig = (new FilterConfig())->setRaiSettings($raiFilterSetting);
    $floorSetting = (new FloorSetting())
        ->setName($floorSettingsName)
        ->setFilterConfig($filterConfig)
        ->setEnableFloorSettingEnforcement(true);

    $updateRequest = (new UpdateFloorSettingRequest())->setFloorSetting($floorSetting);

    $response = $client->updateFloorSetting($updateRequest);

    printf("Floor setting updated: %s\n", $response->getName());
}

Atualize a configuração de limite do Model Armor para uma determinada organização.

use Google\Cloud\ModelArmor\V1\Client\ModelArmorClient;
use Google\Cloud\ModelArmor\V1\RaiFilterType;
use Google\Cloud\ModelArmor\V1\DetectionConfidenceLevel;
use Google\Cloud\ModelArmor\V1\UpdateFloorSettingRequest;
use Google\Cloud\ModelArmor\V1\FilterConfig;
use Google\Cloud\ModelArmor\V1\FloorSetting;
use Google\Cloud\ModelArmor\V1\RaiFilterSettings;
use Google\Cloud\ModelArmor\V1\RaiFilterSettings\RaiFilter;

/**
 * Updates the floor settings for a given organization.
 *
 * @param string $organizationId The organization Id for which the floor settings is to be updated.
 *
 */
function update_organization_floor_settings(string $organizationId)
{
    $client = new ModelArmorClient();

    $floorSettingsName = sprintf('organizations/%s/locations/global/floorSetting', $organizationId);

    // Build the floor settings with your preferred filters
    // For more details on filters, please refer to the following doc:
    // https://cloud.google.com/security-command-center/docs/key-concepts-model-armor#ma-filters

    $raiFilterSetting = (new RaiFilterSettings())
        ->setRaiFilters([
            (new RaiFilter())
                ->setFilterType(RaiFilterType::HATE_SPEECH)
                ->setConfidenceLevel(DetectionConfidenceLevel::HIGH)
        ]);

    $filterConfig = (new FilterConfig())->setRaiSettings($raiFilterSetting);
    $floorSetting = (new FloorSetting())
        ->setName($floorSettingsName)
        ->setFilterConfig($filterConfig)
        ->setEnableFloorSettingEnforcement(true);

    $updateRequest = (new UpdateFloorSettingRequest())->setFloorSetting($floorSetting);

    $response = $client->updateFloorSetting($updateRequest);

    printf("Floor setting updated: %s\n", $response->getName());
}

Python

Para executar esse código, primeiro configure um ambiente de desenvolvimento Python e instale o SDK do Model Armor para Python.

Atualiza a configuração de limite do Model Armor para um determinado projeto.


from google.cloud import modelarmor_v1

# Create the Model Armor client.
client = modelarmor_v1.ModelArmorClient(transport="rest")

# TODO(Developer): Uncomment these variables.
# project_id = "YOUR_PROJECT_ID"

# Prepare project floor setting path/name
floor_settings_name = f"projects/{project_id}/locations/global/floorSetting"

# Update the project floor setting
# For more details on filters, please refer to the following doc:
# https://cloud.google.com/security-command-center/docs/key-concepts-model-armor#ma-filters
response = client.update_floor_setting(
    request=modelarmor_v1.UpdateFloorSettingRequest(
        floor_setting=modelarmor_v1.FloorSetting(
            name=floor_settings_name,
            filter_config=modelarmor_v1.FilterConfig(
                rai_settings=modelarmor_v1.RaiFilterSettings(
                    rai_filters=[
                        modelarmor_v1.RaiFilterSettings.RaiFilter(
                            filter_type=modelarmor_v1.RaiFilterType.HATE_SPEECH,
                            confidence_level=modelarmor_v1.DetectionConfidenceLevel.HIGH,
                        )
                    ]
                ),
            ),
            enable_floor_setting_enforcement=True,
        )
    )
)
# Print the updated config
print(response)

Atualiza a configuração do Model Armor Floor para uma determinada pasta.


from google.cloud import modelarmor_v1

# Create the Model Armor client.
client = modelarmor_v1.ModelArmorClient(transport="rest")

# TODO (Developer): Uncomment these variables and initialize
# folder_id = "YOUR_FOLDER_ID"

# Prepare folder floor settings path/name
floor_settings_name = f"folders/{folder_id}/locations/global/floorSetting"

# Update the folder floor setting
# For more details on filters, please refer to the following doc:
# https://cloud.google.com/security-command-center/docs/key-concepts-model-armor#ma-filters
response = client.update_floor_setting(
    request=modelarmor_v1.UpdateFloorSettingRequest(
        floor_setting=modelarmor_v1.FloorSetting(
            name=floor_settings_name,
            filter_config=modelarmor_v1.FilterConfig(
                rai_settings=modelarmor_v1.RaiFilterSettings(
                    rai_filters=[
                        modelarmor_v1.RaiFilterSettings.RaiFilter(
                            filter_type=modelarmor_v1.RaiFilterType.HATE_SPEECH,
                            confidence_level=modelarmor_v1.DetectionConfidenceLevel.HIGH,
                        )
                    ]
                ),
            ),
            enable_floor_setting_enforcement=True,
        )
    )
)
# Print the updated config
print(response)

Atualize a configuração de limite do Model Armor para uma determinada organização.


from google.cloud import modelarmor_v1

# Create the Model Armor client.
client = modelarmor_v1.ModelArmorClient(transport="rest")

# TODO (Developer): Uncomment these variables and initialize
# organization_id = "YOUR_ORGANIZATION_ID"

# Prepare organization floor setting path/name
floor_settings_name = (
    f"organizations/{organization_id}/locations/global/floorSetting"
)

# Update the organization floor setting
# For more details on filters, please refer to the following doc:
# https://cloud.google.com/security-command-center/docs/key-concepts-model-armor#ma-filters
response = client.update_floor_setting(
    request=modelarmor_v1.UpdateFloorSettingRequest(
        floor_setting=modelarmor_v1.FloorSetting(
            name=floor_settings_name,
            filter_config=modelarmor_v1.FilterConfig(
                rai_settings=modelarmor_v1.RaiFilterSettings(
                    rai_filters=[
                        modelarmor_v1.RaiFilterSettings.RaiFilter(
                            filter_type=modelarmor_v1.RaiFilterType.HATE_SPEECH,
                            confidence_level=modelarmor_v1.DetectionConfidenceLevel.HIGH,
                        )
                    ]
                ),
            ),
            enable_floor_setting_enforcement=True,
        )
    )
)
# Print the updated config
print(response)

Analisar descobertas sobre violação de configuração mínima

Cada descoberta do Model Armor identifica uma violação da configuração mínima. Uma violação ocorre quando um modelo do Model Armor não atende aos padrões mínimos de segurança definidos pelas configurações mínimas da hierarquia de recursos. As configurações mínimas definem os requisitos mínimos para modelos.

As descobertas são geradas quando ocorre uma das seguintes violações de configuração de valor mínimo:

Um modelo com configurações menos restritivas é criado antes da configuração das configurações mínimas.
Um modelo não tem os filtros obrigatórios.
Um modelo não atende ao nível de confiança mínimo para os filtros.

Quando uma violação é detectada, uma descoberta de alta gravidade é gerada no Security Command Center (somente se você estiver usando o nível de serviço Premium ou Enterprise do Security Command Center). A descoberta especifica a configuração mínima violada, o modelo não compatível e detalhes sobre a violação.

O exemplo a seguir mostra o campo sourceProperties da descoberta. Essa violação, relacionada ao filtro de URI malicioso, ocorreu porque a configuração do modelo para maliciousUriFilterSettings é DISABLED, mas as configurações mínimas exigem que seja ENABLED.

{
  "filterConfig": {
    "raiSettings": {
      "raiFilters": [
        {
          "filterType": "HATE_SPEECH",
          "confidenceLevel": {
            "floorSettings": "LOW_AND_ABOVE",
            "template": "MEDIUM_AND_ABOVE"
          }
        },
        {
          "filterType": "HARASSMENT",
          "confidenceLevel": {
            "floorSettings": "MEDIUM_AND_ABOVE",
            "template": "HIGH"
          }
        }
      ]
    },
    "piAndJailbreakFilterSettings": {
      "confidenceLevel": {
        "floorSettings": "LOW_AND_ABOVE",
        "template": "HIGH"
      }
    },
    "maliciousUriFilterSettings": {
      "floorSettings": "ENABLED",
      "template": "DISABLED"
    }
  }
}

A seguir

Saiba mais sobre o Model Armor.
Saiba mais sobre os modelos do Model Armor.
Limpe comandos e respostas.
Resolver problemas do Model Armor.

Definir configurações mínimas Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Antes de começar

Receber as permissões necessárias

Ativar APIs

Console

gcloud

Aplicativo de configurações mínimas

Conformidade de modelos e configurações mínimas

Integração com servidores MCP da Vertex AI e do Google Cloud

Definir configurações mínimas

Definir como as configurações mínimas são herdadas

Definir onde as configurações mínimas são aplicadas

Ver configurações mínimas do Model Armor

Console

gcloud

REST

C#

Go

Java

Node.js

PHP

Python

Atualizar as configurações do Model Armor Floor

Console

gcloud

REST

C#

Go

Java

Node.js

PHP

Python

Analisar descobertas sobre violação de configuração mínima

A seguir

Definir configurações mínimas