Google utiliza tecnología de IA para traducir contenido a tu idioma preferido. Las traducciones realizadas con IA pueden contener errores.

Crea y administra plantillas

Usarás plantillas de Model Armor para configurar el filtrado de instrucciones recibidas y sus respuestas para tus aplicaciones de IA. Las plantillas proporcionan filtros y umbrales personalizados para varias categorías de seguridad. En este documento, se explica cómo crear y administrar plantillas de Model Armor. Para obtener más información, consulta Plantillas de Model Armor.

Usa un extremo regional o multirregional

Cuando trabajas con una plantilla de Model Armor, debes usar un extremo regional o multirregional (modelarmor.LOCATION.rep.googleapis.com) que coincida con la ubicación de la plantilla. Para obtener información sobre cómo se aplica la residencia de datos en cada región o multirregión, consulta Aplicación de la residencia de datos en las plantillas.

El extremo global (modelarmor.googleapis.com) no admite la administración de plantillas de Model Armor ni la limpieza de instrucciones y respuestas.

Cuándo usar las plantillas de Model Armor

A continuación, se muestran algunos casos de uso comunes:

Estandariza la detección en todas las aplicaciones: Define parámetros de configuración de filtrado centralizados y niveles de umbral a los que pueden hacer referencia varias cargas de trabajo.
Personaliza los umbrales y las configuraciones de detección: Ajusta la sensibilidad del filtro, como establecer umbrales de confianza bajos, medios o altos, y las configuraciones de filtro para distintos casos de uso o entornos.
Configura la defensa de varias categorías: Combina Sensitive Data Protection, la detección de jailbreak, la inspección de URIs maliciosas y los filtros de inyección de instrucciones en una sola política.
Aísla las políticas de desarrollo y producción: Mantén plantillas separadas para probar reglas de filtrado más estrictas en la etapa de pruebas antes de implementarlas en los servicios de producción.

Antes de comenzar

Antes de comenzar, completa las siguientes tareas.

Obtén los permisos necesarios

Para obtener los permisos que necesitas para administrar las plantillas de Model Armor, pídele a tu administrador que te otorgue el rol de IAM de Administrador de Model Armor (roles/modelarmor.admin) en el proyecto que contiene la plantilla de Model Armor. Para obtener más información sobre cómo otorgar roles, consulta Administra el acceso a proyectos, carpetas y organizaciones.

También puedes obtener los permisos necesarios a través de roles personalizados o cualquier otro rol predefinido.

Habilita las APIs

Para poder usar la API de Model Armor, debes habilitarla.

Console

Habilita la API de Model Armor si aún no está habilitada.
Roles necesarios para habilitar las APIs
Para habilitar las APIs, necesitas el permiso serviceusage.services.enable. Si creaste el proyecto, es probable que ya tengas este permiso a través del rol de propietario (roles/owner). De lo contrario, puedes obtenerlo a través del rol de administrador de Service Usage (roles/serviceusage.serviceUsageAdmin). Obtén información para otorgar roles.
Habilitar la API
Elige el proyecto en el que quieres activar Model Armor.

gcloud

Antes de empezar, sigue estos pasos a través de la Google Cloud CLI con la API de Model Armor:

En la consola de Google Cloud , activa Cloud Shell.

Activa Cloud Shell

En la parte inferior de la consola de Google Cloud , se inicia una sesión de Cloud Shell en la que se muestra una ventana de línea de comandos. Cloud Shell es un entorno de shell con Google Cloud CLI ya instalada y con valores ya establecidos para el proyecto actual. La sesión puede tardar unos segundos en inicializarse.
Habilita la API de Model Armor si aún no está habilitada:
Roles necesarios para habilitar las APIs
Para habilitar las APIs, necesitas el permiso serviceusage.services.enable. Si creaste el proyecto, es probable que ya tengas este permiso a través del rol de propietario (roles/owner). De lo contrario, puedes obtenerlo a través del rol de administrador de Service Usage (roles/serviceusage.serviceUsageAdmin). Obtén más información para otorgar roles.
```
gcloud services enable modelarmor.googleapis.com
```
Configura la anulación del extremo de API con la gcloud CLI.

Configura la anulación del extremo de API con gcloud CLI

Este paso solo es necesario si usas gcloud CLI con Model Armor y quieres usar una región o multirregión que no sea la multirregión us predeterminada. Debes configurar de forma manual la anulación del extremo de API para asegurarte de que gcloud CLI enrute correctamente las solicitudes al servicio de Model Armor.

Ejecuta el comando siguiente para configurar el extremo de API del servicio de Model Armor.

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

Reemplaza LOCATION por la región o multirregión en la que quieres usar Model Armor.

Crea una plantilla de Model Armor

Las plantillas de Model Armor definen los filtros y umbrales específicos que Model Armor usa para analizar las instrucciones y respuestas en busca de riesgos de seguridad. Para crear una plantilla de Model Armor, sigue estos pasos:

Console

En la consola de Google Cloud , accede a la página de Model Armor.

Acceder a Model Armor
Verifica que estés viendo el proyecto en el que activaste Model Armor.
En la página de Model Armor, haz clic en Crear plantilla. Aparecerá la página Crear plantilla.
Especifica el ID de plantilla. El ID de plantilla puede contener letras, dígitos, guiones bajos o guiones. No puede superar los 63 caracteres, contener espacios ni comenzar con un guion.
En la sección Tipo de ubicación, selecciona una región o multirregión en la que se ejecutarán las operaciones de Model Armor. No podrás cambiar la ubicación más adelante.
Opcional: En la sección Cumplimiento de la residencia de datos, elige si deseas habilitar la aplicación de la residencia de datos. De forma predeterminada, cualquier función de Model Armor que no esté alojada de forma local en la ubicación seleccionada se inhabilita para evitar que tus datos se crucen a otras jurisdicciones. Las funciones inhabilitadas se enumeran en esta sección.

Para habilitar las funciones que están restringidas por la aplicación de la residencia de datos, inhabilita la opción Aplicar la residencia de datos. Esta acción permite el enrutamiento de tus datos entre jurisdicciones.

Precaución: El enrutamiento de tus datos entre jurisdicciones puede afectar el cumplimiento de la residencia de datos.
Opcional: En la sección Etiquetas, agrega los pares clave-valor que quieras usar para agrupar plantillas relacionadas.
En la sección Versión del filtro, selecciona el número de versión del filtro o el alias de la versión del filtro.
Selecciona la modalidad para especificar si quieres filtrar texto, imágenes o ambos.

Nota: Solo las multirregiones us y eu admiten la modalidad de imagen. Si seleccionas cualquier otra región, se inhabilitará el campo Seleccionar modalidad.
En la sección Detecciones, establece la configuración de detección.
Opcional: Si seleccionas la detección de Sensitive Data Protection, debes establecer la configuración de Sensitive Data Protection.
En la sección IA responsable, establece el nivel de confianza para cada filtro de contenido.

Nota: Si no especificas un nivel de confianza, se establece en Alto de forma predeterminada.
Opcional: Expande la sección Configuración adicional (opcional) y establece cualquiera de los siguientes parámetros de configuración:
- En la sección Configura el registro, elige las operaciones para las que quieres configurar el registro.
- En la sección Compatibilidad con varios idiomas, selecciona Habilitar la compatibilidad con varios idiomas para usar la detección de varios idiomas.
- En la sección Modo de aplicación, selecciona un tipo de aplicación.
Haz clic en Crear.

gcloud

Ejecuta el siguiente comando:

 gcloud model-armor templates create TEMPLATE_ID --project=PROJECT_ID --location=LOCATION \
     --rai-settings-filters='[{ "filterType": "HATE_SPEECH", "confidenceLevel": "MEDIUM_AND_ABOVE" },{ "filterType": "HARASSMENT", "confidenceLevel": "MEDIUM_AND_ABOVE" },{ "filterType": "SEXUALLY_EXPLICIT", "confidenceLevel": "MEDIUM_AND_ABOVE" }]' \
     --basic-config-filter-enforcement=enabled  \
     --pi-and-jailbreak-filter-settings-enforcement=enabled \
     --pi-and-jailbreak-filter-settings-confidence-level=HIGH \
     --malicious-uri-filter-settings-enforcement=enabled \
     --template-metadata-custom-llm-response-safety-error-code=798 \
     --template-metadata-custom-llm-response-safety-error-message="test template llm response evaluation failed" \
     --template-metadata-custom-prompt-safety-error-code=799 \
     --template-metadata-custom-prompt-safety-error-message="test template prompt evaluation failed" \
     --template-metadata-ignore-partial-invocation-failures \
     --template-metadata-log-operations \
     --template-metadata-log-sanitize-operations

Reemplaza lo siguiente:

LOCATION: Es la ubicación de la plantilla.
TEMPLATE_ID: Es el ID de la plantilla.
PROJECT_ID: Es el ID del proyecto al que pertenece la plantilla.

REST

Usa el siguiente comando para crear una plantilla de Model Armor nueva.

  curl -X POST \
    -d "FILTER_CONFIG" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
        "https://modelarmor.LOCATION.rep.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/templates?template_id=TEMPLATE_ID"

Reemplaza lo siguiente:

FILTER_CONFIG: Es la configuración del filtro para la plantilla en formato JSON.
PROJECT_ID: Es el ID del proyecto al que pertenece la plantilla.
TEMPLATE_ID: Es el ID de la plantilla que se creará.
LOCATION: Es la ubicación de la plantilla.

En el siguiente ejemplo, se muestra la configuración del filtro de Model Armor (FilterConfig), en la que defines lo que quieres detectar. En este ejemplo, los filtros de IA responsable están configurados para la incitación al odio o a la violencia, el hostigamiento, el contenido peligroso y el contenido sexual explícito con diferentes niveles de confianza. El filtro de detección de inyección de instrucciones y jailbreak está habilitado con un nivel de confianza HIGH, lo que significa que solo se marcará el contenido con una probabilidad alta. El filtro de URI malicioso está habilitado.

  export FILTER_CONFIG='{
   "filterConfig": {
    "raiSettings": {
     "raiFilters": [{
       "filterType": "HATE_SPEECH",
       "confidenceLevel": "MEDIUM_AND_ABOVE"
      }, {
      "filterType": "HARASSMENT",
      "confidenceLevel": "HIGH"
    }, {
      "filterType": "DANGEROUS",
      "confidenceLevel": "MEDIUM_AND_ABOVE"
    },{
      "filterType": "SEXUALLY_EXPLICIT",
      "confidenceLevel": "MEDIUM_AND_ABOVE"
    }]
  },

  "piAndJailbreakFilterSettings": {
    "filterEnforcement": "ENABLED",
    "confidenceLevel": "HIGH"
  },
  "maliciousUriFilterSettings": {
    "filterEnforcement": "ENABLED"
  }
 }
}'

curl -X POST \
 -d "$FILTER_CONFIG" \
 -H "Content-Type: application/json" \
 -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    "https://modelarmor.LOCATION.rep.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/templates?template_id=TEMPLATE_ID"

Para definir cómo Model Armor controla las operaciones, los errores y los registros, establece los metadatos de la plantilla (TemplateMetadata) en tu comando. Los metadatos de la plantilla incluyen parámetros de configuración para la detección de idiomas, las modalidades y el cumplimiento de la residencia de los datos.

En el siguiente ejemplo, se crea una configuración de plantilla de Model Armor que tiene habilitadas la detección y las modalidades (imagen y texto) en varios idiomas.

  export TEMPLATE_CONFIG='{
   "filterConfig": {
    "raiSettings": {
     "raiFilters": [{
       "filterType": "HATE_SPEECH",
       "confidenceLevel": "MEDIUM_AND_ABOVE"
      }, {
      "filterType": "HARASSMENT",
      "confidenceLevel": "HIGH"
    }, {
      "filterType": "DANGEROUS",
      "confidenceLevel": "MEDIUM_AND_ABOVE"
    },{
      "filterType": "SEXUALLY_EXPLICIT",
      "confidenceLevel": "MEDIUM_AND_ABOVE"
    }]
  },

  "piAndJailbreakFilterSettings": {
    "filterEnforcement": "ENABLED",
    "confidenceLevel": "HIGH"
  },
  "maliciousUriFilterSettings": {
    "filterEnforcement": "ENABLED"
  }
 },
 "templateMetadata": {
    "multiLanguageDetection": {
      "enableMultiLanguageDetection": true
    },
    "modalities": ["MODALITY_IMAGE", "MODALITY_TEXT"]
  }
}'

curl -X POST \
 -d "$TEMPLATE_CONFIG"  \
 -H "Content-Type: application/json" \
 -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    "https://modelarmor.LOCATION.rep.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/templates?template_id=TEMPLATE_ID"

C#

Para ejecutar este código, primero configura un entorno de desarrollo de C# y, luego, instala el SDK de C# para Model Armor.

using Google.Api.Gax.ResourceNames;
using Google.Cloud.ModelArmor.V1;
using System.Collections.Generic;

public class CreateTemplateSample
{
    public Template CreateTemplate(
        string projectId = "my-project",
        string locationId = "us-central1",
        string templateId = "my-template"
    )
    {
        ModelArmorClient client = new ModelArmorClientBuilder
        {
            Endpoint = $"modelarmor.{locationId}.rep.googleapis.com",
        }.Build();

        // Build the Model Armor template 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

        // Configure Responsible AI filter with multiple categories and their confidence
        // levels.
        RaiFilterSettings raiFilterSettings = new RaiFilterSettings();
        List<RaiFilterSettings.Types.RaiFilter> filters =
            new List<RaiFilterSettings.Types.RaiFilter>
            {
                new RaiFilterSettings.Types.RaiFilter
                {
                    FilterType = RaiFilterType.Dangerous,
                    ConfidenceLevel = DetectionConfidenceLevel.High,
                },
                new RaiFilterSettings.Types.RaiFilter
                {
                    FilterType = RaiFilterType.HateSpeech,
                    ConfidenceLevel = DetectionConfidenceLevel.High,
                },
                new RaiFilterSettings.Types.RaiFilter
                {
                    FilterType = RaiFilterType.SexuallyExplicit,
                    ConfidenceLevel = DetectionConfidenceLevel.LowAndAbove,
                },
                new RaiFilterSettings.Types.RaiFilter
                {
                    FilterType = RaiFilterType.Harassment,
                    ConfidenceLevel = DetectionConfidenceLevel.MediumAndAbove,
                },
            };

        raiFilterSettings.RaiFilters.Add(filters);

        Template template = new Template
        {
            FilterConfig = new FilterConfig { RaiSettings = raiFilterSettings },
        };

        CreateTemplateRequest request = new CreateTemplateRequest
        {
            ParentAsLocationName = LocationName.FromProjectLocation(projectId, locationId),
            TemplateId = templateId,
            Template = template,
        };

        Template createdTemplate = client.CreateTemplate(request);
        System.Console.WriteLine($"Created template: {createdTemplate.Name}");

        return createdTemplate;
    }
}

Go

Para ejecutar este código, primero configura un entorno de desarrollo de Go y, luego, instala el SDK de Go para Model Armor.


import (
	"context"
	"fmt"
	"io"

	modelarmor "cloud.google.com/go/modelarmor/apiv1"
	modelarmorpb "cloud.google.com/go/modelarmor/apiv1/modelarmorpb"
	"google.golang.org/api/option"
)

// createModelArmorTemplate method creates a new
// Model Armor template with the provided settings.
//
// w io.Writer: The writer to use for logging.
// projectID string: The ID of the Google Cloud project.
// locationID string: The ID of the Google Cloud location.
// templateID string: The ID of the template to create.
func createModelArmorTemplate(w io.Writer, projectID, locationID, templateID string) error {
	ctx := context.Background()

	// Create the call options
	opts := option.WithEndpoint(fmt.Sprintf("modelarmor.%s.rep.googleapis.com:443", locationID))
	// Create the Model Armor client.
	client, err := modelarmor.NewClient(ctx, opts)
	if err != nil {
		return fmt.Errorf("failed to create client for project %s, location %s: %w", projectID, locationID, err)
	}
	defer client.Close()

	// Build the Model Armor template 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](https://cloud.google.com/security-command-center/docs/key-concepts-model-armor#ma-filters)
	template := &modelarmorpb.Template{
		FilterConfig: &modelarmorpb.FilterConfig{
			PiAndJailbreakFilterSettings: &modelarmorpb.PiAndJailbreakFilterSettings{
				FilterEnforcement: modelarmorpb.PiAndJailbreakFilterSettings_ENABLED,
				ConfidenceLevel:   modelarmorpb.DetectionConfidenceLevel_MEDIUM_AND_ABOVE,
			},
			MaliciousUriFilterSettings: &modelarmorpb.MaliciousUriFilterSettings{
				FilterEnforcement: modelarmorpb.MaliciousUriFilterSettings_ENABLED,
			},
		},
	}
	parent := fmt.Sprintf("projects/%s/locations/%s", projectID, locationID)

	// Prepare the request for creating the template.
	req := &modelarmorpb.CreateTemplateRequest{
		Parent:     parent,
		TemplateId: templateID,
		Template:   template,
	}

	// Create the template.
	response, err := client.CreateTemplate(ctx, req)
	if err != nil {
		return fmt.Errorf("failed to create template: %v", err)
	}

	// Print the new template name using fmt.Fprintf with the io.Writer.
	fmt.Fprintf(w, "Created template: %s\n", response.Name)

	return err
}

Java

Para ejecutar este código, primero configura un entorno de desarrollo de Java y, luego, instala el SDK de Java para Model Armor.


import com.google.cloud.modelarmor.v1.CreateTemplateRequest;
import com.google.cloud.modelarmor.v1.DetectionConfidenceLevel;
import com.google.cloud.modelarmor.v1.FilterConfig;
import com.google.cloud.modelarmor.v1.LocationName;
import com.google.cloud.modelarmor.v1.ModelArmorClient;
import com.google.cloud.modelarmor.v1.ModelArmorSettings;
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.Template;
import java.io.IOException;
import java.util.List;

public class CreateTemplate {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.

    // Specify the Google Project ID.
    String projectId = "your-project-id";
    // Specify the location ID. For example, us-central1. 
    String locationId = "your-location-id";
    // Specify the template ID.
    String templateId = "your-template-id";

    createTemplate(projectId, locationId, templateId);
  }

  public static Template createTemplate(String projectId, String locationId, String templateId)
      throws IOException {
    // Construct the API endpoint URL.
    String apiEndpoint = String.format("modelarmor.%s.rep.googleapis.com:443", locationId);
    ModelArmorSettings modelArmorSettings = ModelArmorSettings.newBuilder().setEndpoint(apiEndpoint)
        .build();

    // Initialize the 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(modelArmorSettings)) {
      String parent = LocationName.of(projectId, locationId).toString();

      // Build the Model Armor template 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

      // Configure Responsible AI filter with multiple categories and their confidence
      // levels.
      RaiFilterSettings raiFilterSettings = RaiFilterSettings.newBuilder()
          .addAllRaiFilters(
              List.of(
                  RaiFilter.newBuilder()
                      .setFilterType(RaiFilterType.DANGEROUS)
                      .setConfidenceLevel(DetectionConfidenceLevel.HIGH)
                      .build(),
                  RaiFilter.newBuilder()
                      .setFilterType(RaiFilterType.HATE_SPEECH)
                      .setConfidenceLevel(DetectionConfidenceLevel.HIGH)
                      .build(),
                  RaiFilter.newBuilder()
                      .setFilterType(RaiFilterType.SEXUALLY_EXPLICIT)
                      .setConfidenceLevel(DetectionConfidenceLevel.LOW_AND_ABOVE)
                      .build(),
                  RaiFilter.newBuilder()
                      .setFilterType(RaiFilterType.HARASSMENT)
                      .setConfidenceLevel(DetectionConfidenceLevel.MEDIUM_AND_ABOVE)
                      .build()))
          .build();

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

      Template template = Template.newBuilder()
          .setFilterConfig(modelArmorFilter)
          .build();

      CreateTemplateRequest request = CreateTemplateRequest.newBuilder()
          .setParent(parent)
          .setTemplateId(templateId)
          .setTemplate(template)
          .build();

      Template createdTemplate = client.createTemplate(request);
      System.out.println("Created template: " + createdTemplate.getName());

      return createdTemplate;
    }
  }
}

Node.js

Para ejecutar este código, primero configura un entorno de desarrollo de Node.js y, luego, instala el SDK de Node.js para Model Armor.

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

const parent = `projects/${projectId}/locations/${locationId}`;

// 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({
  apiEndpoint: `modelarmor.${locationId}.rep.googleapis.com`,
});

/**  Build the Model Armor template 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 templateConfig = {
  filterConfig: {
    raiSettings: {
      raiFilters: [
        {
          filterType:
            protos.google.cloud.modelarmor.v1.RaiFilterType.HATE_SPEECH,
          confidenceLevel:
            protos.google.cloud.modelarmor.v1.DetectionConfidenceLevel.HIGH,
        },
        {
          filterType:
            protos.google.cloud.modelarmor.v1.RaiFilterType.SEXUALLY_EXPLICIT,
          confidenceLevel:
            protos.google.cloud.modelarmor.v1.DetectionConfidenceLevel
              .MEDIUM_AND_ABOVE,
        },
      ],
    },
  },
};

// Construct request
const request = {
  parent,
  templateId,
  template: templateConfig,
};

// Create the template
const [response] = await client.createTemplate(request);
return response;

PHP

Para ejecutar este código, primero configura un entorno de desarrollo de PHP y, luego, instala el SDK de PHP para Model Armor.

use Google\Cloud\ModelArmor\V1\Client\ModelArmorClient;
use Google\Cloud\ModelArmor\V1\Template;
use Google\Cloud\ModelArmor\V1\CreateTemplateRequest;
use Google\Cloud\ModelArmor\V1\FilterConfig;
use Google\Cloud\ModelArmor\V1\RaiFilterType;
use Google\Cloud\ModelArmor\V1\RaiFilterSettings;
use Google\Cloud\ModelArmor\V1\RaiFilterSettings\RaiFilter;
use Google\Cloud\ModelArmor\V1\DetectionConfidenceLevel;

/**
 * Create a Model Armor template.
 *
 * @param string $projectId The ID of the project (e.g. 'my-project').
 * @param string $locationId The ID of the location (e.g. 'us-central1').
 * @param string $templateId The ID of the template (e.g. 'my-template').
 */
function create_template(string $projectId, string $locationId, string $templateId): void
{
    $options = ['apiEndpoint' => "modelarmor.$locationId.rep.googleapis.com"];
    $client = new ModelArmorClient($options);
    $parent = $client->locationName($projectId, $locationId);

    /**
     * Build the Model Armor template with preferred filters.
     * For more details on filters, refer to:
     * https://cloud.google.com/security-command-center/docs/key-concepts-model-armor#ma-filters
     */

    $raiFilters = [
        (new RaiFilter())
            ->setFilterType(RaiFilterType::DANGEROUS)
            ->setConfidenceLevel(DetectionConfidenceLevel::HIGH),
        (new RaiFilter())
            ->setFilterType(RaiFilterType::HATE_SPEECH)
            ->setConfidenceLevel(DetectionConfidenceLevel::HIGH),
        (new RaiFilter())
            ->setFilterType(RaiFilterType::SEXUALLY_EXPLICIT)
            ->setConfidenceLevel(DetectionConfidenceLevel::LOW_AND_ABOVE),
        (new RaiFilter())
            ->setFilterType(RaiFilterType::HARASSMENT)
            ->setConfidenceLevel(DetectionConfidenceLevel::MEDIUM_AND_ABOVE),
    ];

    $raiFilterSetting = (new RaiFilterSettings())->setRaiFilters($raiFilters);

    $templateFilterConfig = (new FilterConfig())->setRaiSettings($raiFilterSetting);

    $template = (new Template())->setFilterConfig($templateFilterConfig);

    $request = (new CreateTemplateRequest)
        ->setParent($parent)
        ->setTemplateId($templateId)
        ->setTemplate($template);

    $response = $client->createTemplate($request);

    printf('Template created: %s' . PHP_EOL, $response->getName());
}

Python

Para ejecutar este código, primero configura un entorno de desarrollo de Python y, luego, instala el SDK de Python para Model Armor.


from google.api_core.client_options import ClientOptions
from google.cloud import modelarmor_v1

# TODO(Developer): Uncomment these variables.
# project_id = "your-google-cloud-project-id"
# location_id = "us-central1"
# template_id = "template_id"

# Create the Model Armor client.
client = modelarmor_v1.ModelArmorClient(
    transport="rest",
    client_options=ClientOptions(
        api_endpoint=f"modelarmor.{location_id}.rep.googleapis.com"
    ),
)

# Build the Model Armor template 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
template = modelarmor_v1.Template(
    filter_config=modelarmor_v1.FilterConfig(
        pi_and_jailbreak_filter_settings=modelarmor_v1.PiAndJailbreakFilterSettings(
            filter_enforcement=modelarmor_v1.PiAndJailbreakFilterSettings.PiAndJailbreakFilterEnforcement.ENABLED,
            confidence_level=modelarmor_v1.DetectionConfidenceLevel.MEDIUM_AND_ABOVE,
        ),
        malicious_uri_filter_settings=modelarmor_v1.MaliciousUriFilterSettings(
            filter_enforcement=modelarmor_v1.MaliciousUriFilterSettings.MaliciousUriFilterEnforcement.ENABLED,
        ),
    ),
)

# Prepare the request for creating the template.
request = modelarmor_v1.CreateTemplateRequest(
    parent=f"projects/{project_id}/locations/{location_id}",
    template_id=template_id,
    template=template,
)

# Create the template.
response = client.create_template(request=request)

# Print the new template name.
print(f"Created template: {response.name}")

Configura el cumplimiento de la residencia de datos

De forma predeterminada, cualquier plantilla que crees aplica de forma estricta el cumplimiento de la residencia de los datos. Es decir, se inhabilita cualquier función de Model Armor que no esté alojada dentro de la jurisdicción que abarca la región de la plantilla. La aplicación de medidas por incumplimiento de la residencia de datos evita que tus datos salgan de su jurisdicción.

En el caso de las plantillas que priorizan el filtrado de seguridad integral por sobre la residencia de datos estricta, puedes inhabilitar la aplicación de la residencia de datos para los datos en uso y en tránsito. Para ello, inhabilita la opción Aplicar la residencia de los datos a través de la consola deGoogle Cloud o establece data_residency_compliant en false a través de la API de Model Armor. Tus datos en reposo siguen cumpliendo con los requisitos de residencia de datos, independientemente del estado de esta opción.

Cuando inhabilitas el cumplimiento de la residencia de datos en una plantilla, permites el enrutamiento interjurisdiccional de tus datos. Es decir, Model Armor puede enrutar solicitudes a otras jurisdicciones cuando funciones específicas no estén disponibles de forma local en la jurisdicción de la plantilla.

Inhabilitar el cumplimiento de la residencia de datos habilita todas las funciones de Model Armor, excepto la modalidad de imagen, que sigue restringida a las multirregiones us y eu.

Selecciona una versión del filtro

Las versiones de filtros de Model Armor proporcionan un equilibrio entre la estabilidad para las cargas de trabajo de producción y el acceso a los modelos de detección de amenazas actualizados. Configura la versión del filtro a nivel de la plantilla. La versión del filtro se aplica a todos los filtros de esa plantilla, excepto los que se indican en Filtros que no usan versiones de filtro. Para obtener más información, consulta Establece la versión de filtro para una plantilla.

Selecciona la modalidad

Usa la modalidad para especificar si quieres analizar lo siguiente:

Todo: Analiza texto e imágenes.
Modalidades específicas:
- Texto: Analiza las cadenas de texto y el texto incorporado en los formatos de archivo admitidos.
- Imagen: Analiza imágenes.

Para obtener más información, consulta Filtrado de imágenes y Limpia las instrucciones que contienen imágenes.

Configura las detecciones

Las detecciones son las verificaciones específicas que Model Armor realiza en las instrucciones y las respuestas. Model Armor ofrece un sistema flexible para configurar las detecciones, lo que te permite adaptar el nivel de protección de tus aplicaciones de IA. Las detecciones se configuran cuando creas plantillas. Model Armor realiza las siguientes verificaciones de detección en las instrucciones y las respuestas:

Detección de URLs maliciosas: Identifica direcciones web (URLs) diseñadas para dañar a usuarios o sistemas. Estas URLs podrían dirigir a sitios de phishing, descargas de malware o ciberataques. Para obtener más información, consulta Detección de URLs maliciosas.
Detección de inyección de instrucciones y jailbreak: Detecta contenido malicioso y intentos de jailbreak en una instrucción. Te recomendamos que establezcas el nivel de confianza en Alto para minimizar los falsos positivos y garantizar un comportamiento de detección coherente. Aunque establecer el nivel de confianza en Alto reduce la tasa de falsos positivos, es posible que sigas observando falsos positivos en casos excepcionales. Para obtener más información, consulta Detección de inyección de instrucciones y jailbreak.
Sensitive Data Protection: Detecta datos sensibles y ayuda a evitar la exposición accidental por ataques como la inyección de instrucciones. Para obtener más información, consulta Sensitive Data Protection.

Establece la configuración de Sensitive Data Protection

Model Armor usa Sensitive Data Protection para identificar y evitar la exposición de información sensible en tus interacciones con LLM. Para obtener más información, consulta Sensitive Data Protection.

Model Armor ofrece dos modos para configurar Sensitive Data Protection:

Básico: Es un enfoque más simple que usa infotipos predefinidos para detectar datos sensibles. Para obtener más información sobre los tipos de información predefinidos, consulta Configuración básica de Sensitive Data Protection.
Avanzada: Es una opción más configurable que usa plantillas definidas en Sensitive Data Protection para inspeccionar o desidentificar datos sensibles.

Si seleccionas el modo Avanzado, especifica los siguientes parámetros:

Plantilla de inspección: Son plantillas para guardar información de configuración de los trabajos de análisis de inspección, incluidos los detectores de Infotipo predefinidos o personalizados que se usarán. Ingresa el nombre de la plantilla con el siguiente formato: projects/PROJECT_ID/locations/LOCATION/inspectTemplates/TEMPLATE_ID
Opcional: Plantilla de desidentificación: Son plantillas para guardar información de configuración de trabajos de desidentificación, incluidas las transformaciones de Infotipo y de conjuntos de datos estructurados. Ingresa un identificador para la plantilla de desidentificación en el siguiente formato: projects/PROJECT_ID/locations/LOCATION/deidentifyTemplates/TEMPLATE_ID

Verifica que la plantilla de inspección y la plantilla de desidentificación existan en Sensitive Data Protection. Si la plantilla reside en un proyecto diferente, se le debe otorgar al agente de servicio de Model Armor el rol de usuario de DLP (roles/dlp.user) y el rol de lector de DLP (roles/dlp.reader) para ese proyecto.

Model Armor procesa las solicitudes de manera diferente según si especificas solo una plantilla de inspección o una plantilla de inspección y una de desidentificación:

Solo plantilla de inspección: Model Armor busca en el contenido los tipos de información que se especifican en tu plantilla de inspección y, luego, informa los hallazgos.
Plantilla de inspección y desidentificación: Model Armor desidentifica los tipos de información que se especifican en las plantillas de inspección y desidentificación.

Model Armor desidentifica solo los infoTypes que especificas en tus plantillas de inspección y desidentificación. Por ejemplo, si no especificas CREDIT_CARD_NUMBER en las plantillas de inspección y desidentificación, Model Armor no marcará ni desidentificará los números de tarjetas de crédito que se pasen en las instrucciones y respuestas.

Establece el nivel de confianza

El nivel de confianza representa la probabilidad de que los resultados coincidan con un tipo de filtro de contenido. Puedes establecer el nivel de confianza para cada filtro de contenido. Los valores posibles son los siguientes:

Ninguno: No se detecta contenido.
Bajo y superior: El contenido se detecta con un nivel de confianza bajo, medio o alto.
Medio y superior: El contenido se detecta con un nivel de confianza medio o alto.
Alto: El contenido se detecta con un nivel de confianza alto.

Para una aplicación más estricta, establece el nivel de confianza en Bajo y superior para detectar la mayoría del contenido que se incluye en un tipo de filtro.

Para habilitar el registro integral en una plantilla, consulta Registro de auditoría y de plataforma de Model Armor.

Define el tipo de aplicación de medidas por incumplimiento para las plantillas

Para configurar cómo Model Armor controla las detecciones, establece el tipo de aplicación de política.

En el campo template_metadata de la configuración de la plantilla, establece enforcement_type en INSPECT_ONLY o INSPECT_AND_BLOCK.

export TEMPLATE_CONFIG='{
   "filter_config": {
    "rai_settings": {
     "rai_filters": [{
       "filter_type": "HATE_SPEECH",
       "confidence_level": "MEDIUM_AND_ABOVE"
      }, {
      "filter_type": "HARASSMENT",
      "confidence_level": "MEDIUM_AND_ABOVE"
    }, {
      "filter_type": "DANGEROUS",
      "confidence_level": "MEDIUM_AND_ABOVE"
    },{
      "filter_type": "SEXUALLY_EXPLICIT",
      "confidence_level": "MEDIUM_AND_ABOVE"
    }]
  },
  "pi_and_jailbreak_filter_settings": {
    "filter_enforcement": "ENABLED",
    "confidence_level": "HIGH"
  },
  "malicious_uri_filter_settings": {
    "filter_enforcement": "ENABLED"
  }
 },
 "template_metadata": {
    "enforcement_type": "INSPECT_ONLY",
    "multi_language_detection": {
      "enableMultiLanguageDetection": true
    }
  }
}'

curl -X POST \
    -d "$TEMPLATE_CONFIG"  \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    "https://modelarmor.LOCATION.rep.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/templates?template_id=TEMPLATE_ID"

Reemplaza lo siguiente:

PROJECT_ID: Es el ID del proyecto al que pertenece la plantilla.
TEMPLATE_ID: Es el ID de la plantilla que se creará.
LOCATION: Es la ubicación de la plantilla.

Configura reglas de exclusión específicas de la plantilla

Las reglas de exclusión de Model Armor ayudan a mitigar las detecciones de falsos positivos para términos aprobados específicos del dominio, contextos empresariales únicos o soluciones alternativas operativas temporales. Estas reglas se configuran a nivel de la plantilla para los filtros compatibles, de modo que se excluya el contenido benigno de la activación de detecciones. Para obtener más información, consulta Configura reglas de exclusión específicas de la plantilla.

Visualiza una plantilla de Model Armor

Visualiza las plantillas existentes para comprender qué parámetros de configuración están disponibles y para solucionar problemas con el filtro de instrucciones y respuestas.

Console

En la consola de Google Cloud , accede a la página de Model Armor.

Acceder a Model Armor
Verifica que estés viendo el proyecto en el que activaste Model Armor. Se mostrará la página Model Armor con una lista de las plantillas creadas para tu proyecto.
Haz clic en cualquier plantilla de la lista para ver sus detalles.

gcloud

Ejecuta el siguiente comando:

gcloud model-armor templates describe TEMPLATE_ID --project=PROJECT_ID --location=LOCATION

Reemplaza lo siguiente:

LOCATION: Es la ubicación de la plantilla.
TEMPLATE_ID: Es el ID de la plantilla.
PROJECT_ID: Es el ID del proyecto al que pertenece la plantilla.

REST

Ejecuta el comando siguiente:

curl -X GET \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
  "https://modelarmor.LOCATION.rep.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/templates/TEMPLATE_ID"

Reemplaza lo siguiente:

PROJECT_ID: Es el ID del proyecto al que pertenece la plantilla.
TEMPLATE_ID: Es el ID de la plantilla que se verá.
LOCATION: Es la ubicación de la plantilla.

C#

Para ejecutar este código, primero configura un entorno de desarrollo de C# y, luego, instala el SDK de C# para Model Armor.

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

public class GetTemplateSample
{
    public Template GetTemplate(
        string projectId = "my-project",
        string locationId = "us-central1",
        string templateId = "my-template"
    )
    {
        ModelArmorClient client = new ModelArmorClientBuilder
        {
            Endpoint = $"modelarmor.{locationId}.rep.googleapis.com",
        }.Build();

        GetTemplateRequest request = new GetTemplateRequest
        {
            TemplateName = TemplateName.FromProjectLocationTemplate(projectId, locationId, templateId),
        };

        Template template = client.GetTemplate(request);
        Console.WriteLine($"Retrieved template: {template.Name}");

        return template;
    }
}

Go

Para ejecutar este código, primero configura un entorno de desarrollo de Go y, luego, instala el SDK de Go para Model Armor.


import (
	"context"
	"fmt"
	"io"

	modelarmor "cloud.google.com/go/modelarmor/apiv1"
	modelarmorpb "cloud.google.com/go/modelarmor/apiv1/modelarmorpb"
	"google.golang.org/api/option"
)

// getModelArmorTemplate method retrieves a Model Armor template.
//
// w io.Writer: The writer to use for logging.
// projectID string: The ID of the project.
// locationID string: The location of the template.
// templateID string: The ID of the template.
func getModelArmorTemplate(w io.Writer, projectID, locationID, templateID string) error {
	ctx := context.Background()

	// Create options for the Model Armor client
	opts := option.WithEndpoint(fmt.Sprintf("modelarmor.%s.rep.googleapis.com:443", locationID))
	// Create the Model Armor client.
	client, err := modelarmor.NewClient(ctx, opts)
	if err != nil {
		return fmt.Errorf("failed to create client for project %s, location %s: %w", projectID, locationID, err)
	}
	defer client.Close()

	// Initialize request arguments.
	req := &modelarmorpb.GetTemplateRequest{
		Name: fmt.Sprintf("projects/%s/locations/%s/templates/%s", projectID, locationID, templateID),
	}

	// Get the template.
	response, err := client.GetTemplate(ctx, req)
	if err != nil {
		return fmt.Errorf("failed to get template: %w", err)
	}

	// Print the template name using fmt.Fprintf with the io.Writer.
	fmt.Fprintf(w, "Retrieved template: %s\n", response.Name)

	return nil
}

Java

Para ejecutar este código, primero configura un entorno de desarrollo de Java y, luego, instala el SDK de Java para Model Armor.


import com.google.cloud.modelarmor.v1.ModelArmorClient;
import com.google.cloud.modelarmor.v1.ModelArmorSettings;
import com.google.cloud.modelarmor.v1.Template;
import com.google.cloud.modelarmor.v1.TemplateName;
import java.io.IOException;

public class GetTemplate {

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

    getTemplate(projectId, locationId, templateId);
  }

  public static Template getTemplate(String projectId, String locationId, String templateId)
      throws IOException {
    // Construct the API endpoint URL.
    String apiEndpoint = String.format("modelarmor.%s.rep.googleapis.com:443", locationId);

    ModelArmorSettings modelArmorSettings = ModelArmorSettings.newBuilder().setEndpoint(apiEndpoint)
        .build();

    // Initialize the 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(modelArmorSettings)) {
      // Build the template name.
      String name = TemplateName.of(projectId, locationId, templateId).toString();

      // Get the template.
      Template template = client.getTemplate(name);

      // Find more details about Template object here:
      // https://cloud.google.com/security-command-center/docs/reference/model-armor/rest/v1/projects.locations.templates#Template
      System.out.printf("Retrieved template: %s\n", template.getName());

      return template;
    }
  }
}

Node.js

Para ejecutar este código, primero configura un entorno de desarrollo de Node.js y, luego, instala el SDK de Node.js para Model Armor.

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'my-project';
// const locationId = 'my-location';
// const templateId = 'my-template';

const name = `projects/${projectId}/locations/${locationId}/templates/${templateId}`;

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

// Instantiates a client
const client = new ModelArmorClient({
  apiEndpoint: `modelarmor.${locationId}.rep.googleapis.com`,
});

const request = {
  name: name,
};

// Run request
const [response] = await client.getTemplate(request);
return response;

PHP

Para ejecutar este código, primero configura un entorno de desarrollo de PHP y, luego, instala el SDK de PHP para Model Armor.

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

/**
 * Gets a Model Armor template.
 *
 * @param string $projectId The ID of your Google Cloud Platform project (e.g. 'my-project').
 * @param string $locationId The ID of the location where the template is stored (e.g. 'us-central1').
 * @param string $templateId The ID of the template (e.g. 'my-template').
 */
function get_template(string $projectId, string $locationId, string $templateId): void
{
    $options = ['apiEndpoint' => "modelarmor.$locationId.rep.googleapis.com"];
    $client = new ModelArmorClient($options);
    $name = sprintf('projects/%s/locations/%s/templates/%s', $projectId, $locationId, $templateId);

    $getTemplateRequest = (new GetTemplateRequest())->setName($name);

    $response = $client->getTemplate($getTemplateRequest);

    printf('Template retrieved: %s' . PHP_EOL, $response->getName());
}

Python

Para ejecutar este código, primero configura un entorno de desarrollo de Python y, luego, instala el SDK de Python para Model Armor.


from google.api_core.client_options import ClientOptions
from google.cloud import modelarmor_v1

# TODO(Developer): Uncomment these variables.
# project_id = "YOUR_PROJECT_ID"
# location_id = "us-central1"
# template_id = "template_id"

# Create the Model Armor client.
client = modelarmor_v1.ModelArmorClient(
    transport="rest",
    client_options=ClientOptions(
        api_endpoint=f"modelarmor.{location_id}.rep.googleapis.com"
    ),
)

# Initialize request arguments.
request = modelarmor_v1.GetTemplateRequest(
    name=f"projects/{project_id}/locations/{location_id}/templates/{template_id}",
)

# Get the template.
response = client.get_template(request=request)
print(response.name)

Actualiza una plantilla de Model Armor

Actualiza tus plantillas con regularidad para mantener una postura de seguridad sólida y eficaz para tus aplicaciones de IA.

Console

En la consola de Google Cloud , accede a la página de Model Armor.

Acceder a Model Armor
Verifica que estés viendo el proyecto en el que activaste Model Armor. Se muestra la página Model Armor con una lista de las plantillas creadas para tu organización.
En la lista, haz clic en la plantilla que quieres actualizar. Aparecerá la página Detalles de la plantilla.
Haz clic en Editar.
Actualiza los parámetros obligatorios y haz clic en Guardar.

gcloud

Para actualizar una plantilla, ejecuta el comando gcloud model-armor templates update e incluye las marcas de los parámetros de configuración que quieras modificar.

Por ejemplo, con el siguiente comando, se actualizan la configuración del filtro y los metadatos de una plantilla:

gcloud model-armor templates update TEMPLATE_ID \
    --project=PROJECT_ID \
    --location=LOCATION \
    --rai-settings-filters='[{ "filterType": "HATE_SPEECH", "confidenceLevel": "MEDIUM_AND_ABOVE" },{ "filterType": "HARASSMENT", "confidenceLevel": "MEDIUM_AND_ABOVE" },{ "filterType": "DANGEROUS", "confidenceLevel": "MEDIUM_AND_ABOVE" },{ "filterType": "SEXUALLY_EXPLICIT", "confidenceLevel": "MEDIUM_AND_ABOVE" }]' \
    --basic-config-filter-enforcement=enabled \
    --pi-and-jailbreak-filter-settings-enforcement=enabled \
    --pi-and-jailbreak-filter-settings-confidence-level=HIGH \
    --malicious-uri-filter-settings-enforcement=enabled \
    --template-metadata-custom-llm-response-safety-error-code=798 \
    --template-metadata-custom-llm-response-safety-error-message="test template llm response evaluation failed" \
    --template-metadata-custom-prompt-safety-error-code=799 \
    --template-metadata-custom-prompt-safety-error-message="test template prompt evaluation failed" \
    --template-metadata-ignore-partial-invocation-failures \
    --template-metadata-log-operations \
    --template-metadata-log-sanitize-operations

Reemplaza lo siguiente:

TEMPLATE_ID: Es el ID de la plantilla.
PROJECT_ID: Es el ID del proyecto al que pertenece la plantilla.
LOCATION: Es la ubicación de la plantilla.

REST

Ejecuta el comando siguiente:

curl -X PATCH \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
-d "$FILTER_CONFIG" \
  "https://modelarmor.LOCATION.rep.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/templates/TEMPLATE_ID?updateMask=UPDATE_MASK"

Reemplaza lo siguiente:

PROJECT_ID: Es el ID del proyecto al que pertenece la plantilla.
LOCATION: Es la ubicación de la plantilla.
TEMPLATE_ID: Es el ID de la plantilla.
UPDATE_MASK: los campos que deseas actualizar, como filterConfig, filterConfig.piAndJailbreakFilterSettings o filterConfig.filterRuleSettings. Para obtener más información, consulta Actualiza las reglas de exclusión en una plantilla. Si dejas este campo vacío, se actualizará toda la configuración del filtro.

Todos los demás campos son inmutables. Los intentos de actualizar otros campos (por ejemplo, los intentos de actualizar el nombre de la plantilla) generan un error.

C#

Para ejecutar este código, primero configura un entorno de desarrollo de C# y, luego, instala el SDK de C# para Model Armor.

using Google.Cloud.ModelArmor.V1;
using Google.Protobuf.WellKnownTypes;
using System;
using System.Collections.Generic;

namespace ModelArmor.Samples
{
    public class UpdateTemplateSample
    {
        public Template UpdateTemplate(
            string projectId = "my-project",
            string locationId = "us-central1",
            string templateId = "my-template"
        )
        {
            // Construct the API endpoint URL.
            ModelArmorClientBuilder clientBuilder = new ModelArmorClientBuilder
            {
                Endpoint = $"modelarmor.{locationId}.rep.googleapis.com",
            };

            // Create the client.
            ModelArmorClient client = clientBuilder.Build();

            // Get the template name.
            TemplateName name = TemplateName.FromProjectLocationTemplate(projectId, locationId, templateId);

            // Build the updated Model Armor template with modified 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
            RaiFilterSettings raiFilterSettings = new RaiFilterSettings();
            List<RaiFilterSettings.Types.RaiFilter> filters =
                new List<RaiFilterSettings.Types.RaiFilter>
                {
                    new RaiFilterSettings.Types.RaiFilter
                    {
                        FilterType = RaiFilterType.Dangerous,
                        ConfidenceLevel = DetectionConfidenceLevel.High,
                    },
                    new RaiFilterSettings.Types.RaiFilter
                    {
                        FilterType = RaiFilterType.HateSpeech,
                        ConfidenceLevel = DetectionConfidenceLevel.MediumAndAbove,
                    },
                    new RaiFilterSettings.Types.RaiFilter
                    {
                        FilterType = RaiFilterType.SexuallyExplicit,
                        ConfidenceLevel = DetectionConfidenceLevel.MediumAndAbove,
                    },
                    new RaiFilterSettings.Types.RaiFilter
                    {
                        FilterType = RaiFilterType.Harassment,
                        ConfidenceLevel = DetectionConfidenceLevel.MediumAndAbove,
                    },
                };

            raiFilterSettings.RaiFilters.Add(filters);

            Template template = new Template
            {
                TemplateName = name,
                FilterConfig = new FilterConfig { RaiSettings = raiFilterSettings },
            };

            // Create a field mask to specify which fields to update.
            // Ref: https://protobuf.dev/reference/protobuf/google.protobuf/#field-mask
            FieldMask updateMask = new FieldMask { Paths = { "filter_config.rai_settings" } };

            // Prepare the request.
            UpdateTemplateRequest request = new UpdateTemplateRequest
            {
                Template = template,
                UpdateMask = updateMask,
            };

            // Send the request.
            Template updatedTemplate = client.UpdateTemplate(request);
            Console.WriteLine($"Updated template: {updatedTemplate.Name}");

            return updatedTemplate;
        }
    }
}

Go

Para ejecutar este código, primero configura un entorno de desarrollo de Go y, luego, instala el SDK de Go para Model Armor.


import (
	"context"
	"fmt"
	"io"

	modelarmor "cloud.google.com/go/modelarmor/apiv1"
	modelarmorpb "cloud.google.com/go/modelarmor/apiv1/modelarmorpb"
	"google.golang.org/api/option"
)

// updateModelArmorTemplate updates a Model Armor template.
//
// updateModelArmorTemplate method updates a Model Armor template.
//
// w io.Writer: The writer to use for logging.
// projectID string: The ID of the project.
// locationID string: The ID of the location.
// templateID string: The ID of the template.
func updateModelArmorTemplate(w io.Writer, projectID, locationID, templateID string) error {
	ctx := context.Background()

	// Create options for Model Armor client.
	opts := option.WithEndpoint(fmt.Sprintf("modelarmor.%s.rep.googleapis.com:443", locationID))
	// Create the Model Armor client.
	client, err := modelarmor.NewClient(ctx, opts)
	if err != nil {
		return fmt.Errorf("failed to create client for project %s, location %s: %w", projectID, locationID, err)
	}
	defer client.Close()

	// Build the Model Armor template 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](https://cloud.google.com/security-command-center/docs/key-concepts-model-armor#ma-filters)
	updatedTemplate := &modelarmorpb.Template{
		Name: fmt.Sprintf("projects/%s/locations/%s/templates/%s", projectID, locationID, templateID),
		FilterConfig: &modelarmorpb.FilterConfig{
			PiAndJailbreakFilterSettings: &modelarmorpb.PiAndJailbreakFilterSettings{
				FilterEnforcement: modelarmorpb.PiAndJailbreakFilterSettings_ENABLED,
				ConfidenceLevel:   modelarmorpb.DetectionConfidenceLevel_LOW_AND_ABOVE,
			},
			MaliciousUriFilterSettings: &modelarmorpb.MaliciousUriFilterSettings{
				FilterEnforcement: modelarmorpb.MaliciousUriFilterSettings_ENABLED,
			},
		},
	}

	// Initialize request argument(s).
	req := &modelarmorpb.UpdateTemplateRequest{
		Template: updatedTemplate,
	}

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

	// Print the updated filters in the template.
	fmt.Fprintf(w, "Updated Filter Config: %+v\n", response.FilterConfig)

	return nil
}

Java

Para ejecutar este código, primero configura un entorno de desarrollo de Java y, luego, instala el SDK de Java para Model Armor.


import com.google.cloud.modelarmor.v1.DetectionConfidenceLevel;
import com.google.cloud.modelarmor.v1.FilterConfig;
import com.google.cloud.modelarmor.v1.ModelArmorClient;
import com.google.cloud.modelarmor.v1.ModelArmorSettings;
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.Template;
import com.google.cloud.modelarmor.v1.TemplateName;
import com.google.cloud.modelarmor.v1.UpdateTemplateRequest;
import com.google.protobuf.FieldMask;
import java.io.IOException;
import java.util.List;

public class UpdateTemplate {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.

    // Specify the Google Project ID.
    String projectId = "your-project-id";
    // Specify the location ID. For example, us-central1. 
    String locationId = "your-location-id";
    // Specify the template ID.
    String templateId = "your-template-id";

    updateTemplate(projectId, locationId, templateId);
  }

  public static Template updateTemplate(String projectId, String locationId, String templateId)
      throws IOException {
    // Construct the API endpoint URL.
    String apiEndpoint = String.format("modelarmor.%s.rep.googleapis.com:443", locationId);
    ModelArmorSettings modelArmorSettings = ModelArmorSettings.newBuilder().setEndpoint(apiEndpoint)
        .build();

    // Initialize the 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(modelArmorSettings)) {
      // Get the template name.
      String name = TemplateName.of(projectId, locationId, templateId).toString();

      // Build the updated Model Armor template with modified 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
      RaiFilterSettings raiFilterSettings =
          RaiFilterSettings.newBuilder()
              .addAllRaiFilters(
                  List.of(
                      RaiFilter.newBuilder()
                          .setFilterType(RaiFilterType.DANGEROUS)
                          .setConfidenceLevel(DetectionConfidenceLevel.HIGH)
                          .build(),
                      RaiFilter.newBuilder()
                          .setFilterType(RaiFilterType.HATE_SPEECH)
                          .setConfidenceLevel(DetectionConfidenceLevel.MEDIUM_AND_ABOVE)
                          .build(),
                      RaiFilter.newBuilder()
                          .setFilterType(RaiFilterType.HARASSMENT)
                          .setConfidenceLevel(DetectionConfidenceLevel.MEDIUM_AND_ABOVE)
                          .build(),
                      RaiFilter.newBuilder()
                          .setFilterType(RaiFilterType.SEXUALLY_EXPLICIT)
                          .setConfidenceLevel(DetectionConfidenceLevel.MEDIUM_AND_ABOVE)
                          .build()))
              .build();

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

      Template template = Template.newBuilder()
          .setName(name)
          .setFilterConfig(modelArmorFilter)
          .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();

      UpdateTemplateRequest request = UpdateTemplateRequest.newBuilder()
          .setTemplate(template)
          .setUpdateMask(updateMask)
          .build();

      Template updatedTemplate = client.updateTemplate(request);
      System.out.println("Updated template: " + updatedTemplate.getName());

      return updatedTemplate;
    }
  }
}

Node.js

Para ejecutar este código, primero configura un entorno de desarrollo de Node.js y, luego, instala el SDK de Node.js para Model Armor.

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

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

const DetectionConfidenceLevel =
  protos.google.cloud.modelarmor.v1.DetectionConfidenceLevel;
const PiAndJailbreakFilterEnforcement =
  protos.google.cloud.modelarmor.v1.PiAndJailbreakFilterSettings
    .PiAndJailbreakFilterEnforcement;
const MaliciousUriFilterEnforcement =
  protos.google.cloud.modelarmor.v1.MaliciousUriFilterSettings
    .MaliciousUriFilterEnforcement;

// Instantiates a client
const client = new ModelArmorClient({
  apiEndpoint: `modelarmor.${locationId}.rep.googleapis.com`,
});

// Build the updated template configuration
const updatedTemplate = {
  name: `projects/${projectId}/locations/${locationId}/templates/${templateId}`,
  filterConfig: {
    piAndJailbreakFilterSettings: {
      filterEnforcement: PiAndJailbreakFilterEnforcement.ENABLED,
      confidenceLevel: DetectionConfidenceLevel.LOW_AND_ABOVE,
    },
    maliciousUriFilterSettings: {
      filterEnforcement: MaliciousUriFilterEnforcement.ENABLED,
    },
  },
};

const request = {
  template: updatedTemplate,
};

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

PHP

Para ejecutar este código, primero configura un entorno de desarrollo de PHP y, luego, instala el SDK de PHP para Model Armor.

use Google\Cloud\ModelArmor\V1\Client\ModelArmorClient;
use Google\Cloud\ModelArmor\V1\DetectionConfidenceLevel;
use Google\Cloud\ModelArmor\V1\PiAndJailbreakFilterSettings\PiAndJailbreakFilterEnforcement;
use Google\Cloud\ModelArmor\V1\PiAndJailbreakFilterSettings;
use Google\Cloud\ModelArmor\V1\MaliciousUriFilterSettings;
use Google\Cloud\ModelArmor\V1\UpdateTemplateRequest;
use Google\Cloud\ModelArmor\V1\FilterConfig;
use Google\Cloud\ModelArmor\V1\Template;

/**
 * Updates a Model Armor template with the specified configuration.
 *
 * @param string $projectId The ID of the project (e.g. 'my-project').
 * @param string $locationId The ID of the location (e.g. 'us-central1').
 * @param string $templateId The ID of the template (e.g. 'my-template').
 */
function update_template(string $projectId, string $locationId, string $templateId): void
{
    $options = ['apiEndpoint' => "modelarmor.$locationId.rep.googleapis.com"];
    $client = new ModelArmorClient($options);

    $templateFilterConfig = (new FilterConfig())
        ->setPiAndJailbreakFilterSettings(
            (new PiAndJailbreakFilterSettings())
                ->setFilterEnforcement(PiAndJailbreakFilterEnforcement::ENABLED)
                ->setConfidenceLevel(DetectionConfidenceLevel::LOW_AND_ABOVE)
        )
        ->setMaliciousUriFilterSettings(
            (new MaliciousUriFilterSettings())
                ->setFilterEnforcement(PiAndJailbreakFilterEnforcement::ENABLED)
        );

    $template = (new Template())
        ->setFilterConfig($templateFilterConfig)
        ->setName("projects/$projectId/locations/$locationId/templates/$templateId");

    $updateTemplateRequest = (new UpdateTemplateRequest())->setTemplate($template);

    $response = $client->updateTemplate($updateTemplateRequest);

    printf('Template updated: %s' . PHP_EOL, $response->getName());
}

Python

Para ejecutar este código, primero configura un entorno de desarrollo de Python y, luego, instala el SDK de Python para Model Armor.


from google.api_core.client_options import ClientOptions
from google.cloud import modelarmor_v1

# TODO(Developer): Uncomment these variables.
# project_id = "YOUR_PROJECT_ID"
# location_id = "us-central1"
# template_id = "template_id"

# Create the Model Armor client.
client = modelarmor_v1.ModelArmorClient(
    transport="rest",
    client_options=ClientOptions(
        api_endpoint=f"modelarmor.{location_id}.rep.googleapis.com"
    ),
)

# Build the Model Armor template 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
updated_template = modelarmor_v1.Template(
    name=f"projects/{project_id}/locations/{location_id}/templates/{template_id}",
    filter_config=modelarmor_v1.FilterConfig(
        pi_and_jailbreak_filter_settings=modelarmor_v1.PiAndJailbreakFilterSettings(
            filter_enforcement=modelarmor_v1.PiAndJailbreakFilterSettings.PiAndJailbreakFilterEnforcement.ENABLED,
            confidence_level=modelarmor_v1.DetectionConfidenceLevel.LOW_AND_ABOVE,
        ),
        malicious_uri_filter_settings=modelarmor_v1.MaliciousUriFilterSettings(
            filter_enforcement=modelarmor_v1.MaliciousUriFilterSettings.MaliciousUriFilterEnforcement.ENABLED,
        ),
    ),
)

# Initialize request argument(s).
request = modelarmor_v1.UpdateTemplateRequest(template=updated_template)

# Update the template.
response = client.update_template(request=request)

# Print the updated filters in the template.
print(response.filter_config)

Borra una plantilla de Model Armor

Borra una plantilla cuando ya no se use, se reemplace por una nueva o cuando cambien las políticas de seguridad.

Console

En la consola de Google Cloud , accede a la página de Model Armor.

Acceder a Model Armor
Verifica que estés viendo el proyecto en el que activaste Model Armor. Se muestra la página Model Armor con una lista de las plantillas creadas para tu organización.
Haz clic en la plantilla que quieres borrar de la lista. Aparecerá la página Detalles de la plantilla.
Haz clic en Borrar. Aparecerá un diálogo de confirmación.
Ingresa el nombre de la plantilla para confirmar la eliminación y haz clic en Borrar.

gcloud

Ejecuta el siguiente comando:

gcloud model-armor templates delete TEMPLATE_ID --project=PROJECT_ID --location=LOCATION

Reemplaza lo siguiente:

LOCATION: Es la ubicación de la plantilla.
TEMPLATE_ID: Es el ID de la plantilla.
PROJECT_ID: Es el ID del proyecto al que pertenece la plantilla.

REST

Ejecuta el comando siguiente:

curl -X DELETE \
-H "Authorization: Bearer $(gcloud auth print-access-token)"  \
  "https://modelarmor.LOCATION.rep.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/templates/TEMPLATE_ID"

Reemplaza lo siguiente:

PROJECT_ID: Es el ID del proyecto al que pertenece la plantilla.
LOCATION: Es la ubicación de la plantilla.
TEMPLATE_ID: Es el ID de la plantilla.

C#

Para ejecutar este código, primero configura un entorno de desarrollo de C# y, luego, instala el SDK de C# para Model Armor.

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

public class DeleteTemplateSample
{
    public void DeleteTemplate(
        string projectId = "my-project",
        string locationId = "us-central1",
        string templateId = "my-template"
    )
    {
        ModelArmorClient client = new ModelArmorClientBuilder
        {
            Endpoint = $"modelarmor.{locationId}.rep.googleapis.com",
        }.Build();

        DeleteTemplateRequest request = new DeleteTemplateRequest
        {
            TemplateName = TemplateName.FromProjectLocationTemplate(projectId, locationId, templateId),
        };

        client.DeleteTemplate(request);
        Console.WriteLine($"Deleted template: {templateId}");
    }
}

Go

Para ejecutar este código, primero configura un entorno de desarrollo de Go y, luego, instala el SDK de Go para Model Armor.


import (
	"context"
	"fmt"
	"io"

	modelarmor "cloud.google.com/go/modelarmor/apiv1"
	modelarmorpb "cloud.google.com/go/modelarmor/apiv1/modelarmorpb"
	"google.golang.org/api/option"
)

// deleteModelArmorTemplate method deletes a Model Armor template with the provided ID.
//
// w io.Writer: The writer to use for logging.
// projectID string: The ID of the Google Cloud project.
// locationID string: The ID of the Google Cloud location.
// templateID string: The ID of the template to delete.
func deleteModelArmorTemplate(w io.Writer, projectID, locationID, templateID string) error {
	ctx := context.Background()

	// Create option for Model Armor client.
	opts := option.WithEndpoint(fmt.Sprintf("modelarmor.%s.rep.googleapis.com:443", locationID))
	// Create the Model Armor client.
	client, err := modelarmor.NewClient(ctx, opts)
	if err != nil {
		return fmt.Errorf("failed to create client for project %s, location %s: %w", projectID, locationID, err)
	}
	defer client.Close()

	// Build the request for deleting the template.
	req := &modelarmorpb.DeleteTemplateRequest{
		Name: fmt.Sprintf("projects/%s/locations/%s/templates/%s", projectID, locationID, templateID),
	}

	// Delete the template.
	if err := client.DeleteTemplate(ctx, req); err != nil {
		return fmt.Errorf("failed to delete template: %w", err)
	}

	// Print the success message using fmt.Fprintf with the io.Writer.
	fmt.Fprintf(w, "Successfully deleted Model Armor template: %s\n", req.Name)

	return err
}

Java

Para ejecutar este código, primero configura un entorno de desarrollo de Java y, luego, instala el SDK de Java para Model Armor.


import com.google.cloud.modelarmor.v1.ModelArmorClient;
import com.google.cloud.modelarmor.v1.ModelArmorSettings;
import com.google.cloud.modelarmor.v1.TemplateName;
import java.io.IOException;

public class DeleteTemplate {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.

    // Specify the Google Project ID.
    String projectId = "your-project-id";
    // Specify the location ID. For example, us-central1.
    String locationId = "your-location-id";
    // Specify the template ID.
    String templateId = "your-template-id";

    deleteTemplate(projectId, locationId, templateId);
  }

  public static void deleteTemplate(String projectId, String locationId, String templateId)
      throws IOException {

    // Construct the API endpoint URL.
    String apiEndpoint = String.format("modelarmor.%s.rep.googleapis.com:443", locationId);
    ModelArmorSettings modelArmorSettings = ModelArmorSettings.newBuilder().setEndpoint(apiEndpoint)
        .build();

    // Initialize the 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(modelArmorSettings)) {
      String name = TemplateName.of(projectId, locationId, templateId).toString();

      // Note: Ensure that the template you are deleting isn't used by any models.
      client.deleteTemplate(name);
      System.out.println("Deleted template: " + name);
    }
  }
}

Node.js

Para ejecutar este código, primero configura un entorno de desarrollo de Node.js y, luego, instala el SDK de Node.js para Model Armor.

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'my-project';
// const locationId = 'us-central1';
// const templateId = 'my-template';

const name = `projects/${projectId}/locations/${locationId}/templates/${templateId}`;

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

// Instantiates a client
const client = new ModelArmorClient({
  apiEndpoint: `modelarmor.${locationId}.rep.googleapis.com`,
});

const response = await client.deleteTemplate({
  name: name,
});
return response;

PHP

Para ejecutar este código, primero configura un entorno de desarrollo de PHP y, luego, instala el SDK de PHP para Model Armor.

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

/**
 * Deletes a Model Armor template.
 *
 * @param string $projectId The ID of the project (e.g. 'my-project').
 * @param string $locationId The ID of the location (e.g. 'us-central1').
 * @param string $templateId The ID of the template (e.g. 'my-template').
 */
function delete_template(string $projectId, string $locationId, string $templateId): void
{
    $options = ['apiEndpoint' => "modelarmor.$locationId.rep.googleapis.com"];
    $client = new ModelArmorClient($options);
    $templateName = sprintf('projects/%s/locations/%s/templates/%s', $projectId, $locationId, $templateId);

    $dltTemplateRequest = (new DeleteTemplateRequest())->setName($templateName);

    $client->deleteTemplate($dltTemplateRequest);

    printf('Deleted template: %s' . PHP_EOL, $templateName);
}

Python

Para ejecutar este código, primero configura un entorno de desarrollo de Python y, luego, instala el SDK de Python para Model Armor.


from google.api_core.client_options import ClientOptions
from google.cloud import modelarmor_v1

# TODO(Developer): Uncomment these variables.
# project_id = "YOUR_PROJECT_ID"
# location_id = "us-central1"
# template_id = "template_id"

# Create the Model Armor client.
client = modelarmor_v1.ModelArmorClient(
    transport="rest",
    client_options=ClientOptions(
        api_endpoint=f"modelarmor.{location_id}.rep.googleapis.com"
    ),
)

# Build the request for deleting the template.
request = modelarmor_v1.DeleteTemplateRequest(
    name=f"projects/{project_id}/locations/{location_id}/templates/{template_id}",
)

# Delete the template.
client.delete_template(request=request)

Metadatos de la plantilla

Los metadatos de la plantilla de Model Armor te ayudan a configurar el comportamiento de Model Armor, incluido el manejo de las verificaciones de seguridad, el manejo de errores y el comportamiento de los registros.

Los metadatos de la plantilla para Model Armor incluyen los siguientes campos:

Metadatos	Tipo	Valor predeterminado	Descripción
enforcement_type	Enum	`INSPECT_AND_BLOCK`	Define el tipo de aplicación de medidas por incumplimiento. Usa uno de los siguientes valores: `INSPECT_ONLY`: Model Armor inspecciona las solicitudes que infringen la configuración, pero no las bloquea. `INSPECT_AND_BLOCK`: Model Armor bloquea las solicitudes que infringen la configuración.
log_template_operations	Booleano	Falso	Habilita el registro de las operaciones de plantilla.
log_sanitize_operations	Booleano	Falso	Habilita el registro de las operaciones de limpieza.
multiLanguageDetection	Booleano	Falso	Habilita la detección de varios idiomas.
modalidades (versión preliminar)	Enum	Vacío	Determina si se debe analizar texto, imágenes o ambos. Si dejas este campo vacío, solo se analizará el texto. Usa uno de los siguientes valores: `TEXT`: Analiza cadenas de texto y texto incorporado en los formatos de archivo admitidos. `IMAGE`: Analiza imágenes.
data_residency_compliant	Booleano	Verdadero	Indica si la plantilla está sujeta al cumplimiento estricto de la residencia de datos (procesamiento dentro de la jurisdicción). `True`: Inhabilita las funciones que no se admiten de forma local dentro de la jurisdicción de la región de tu plantilla para evitar que los datos salgan de la jurisdicción local. `False`: Inhabilita las verificaciones de cumplimiento de residencia de datos y permite el enrutamiento interjurisdiccional de tus datos cuando una función no está disponible de forma local en la jurisdicción. Para obtener más información sobre este campo, consulta Establece el cumplimiento de la residencia de datos en este documento. Para obtener más información sobre la residencia de datos de las plantillas, consulta Aplicación de la residencia de datos para las plantillas.

¿Qué sigue?

Obtén más información sobre la descripción general de Model Armor.
Obtén más información sobre la configuración mínima de Model Armor.
Limpia instrucciones y respuestas.
Soluciona problemas de Model Armor.

Crea y administra plantillas Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

Usa un extremo regional o multirregional

Cuándo usar las plantillas de Model Armor

Antes de comenzar

Obtén los permisos necesarios

Habilita las APIs

Console

gcloud

Configura la anulación del extremo de API con gcloud CLI

Crea una plantilla de Model Armor

Console

gcloud

REST

C#

Go

Java

Node.js

PHP

Python

Configura el cumplimiento de la residencia de datos

Selecciona una versión del filtro

Selecciona la modalidad

Configura las detecciones

Establece la configuración de Sensitive Data Protection

Establece el nivel de confianza

Define el tipo de aplicación de medidas por incumplimiento para las plantillas

Configura reglas de exclusión específicas de la plantilla

Visualiza una plantilla de Model Armor

Console

gcloud

REST

C#

Go

Java

Node.js

PHP

Python

Actualiza una plantilla de Model Armor

Console

gcloud

REST

C#

Go

Java

Node.js

PHP

Python

Borra una plantilla de Model Armor

Console

gcloud

REST

C#

Go

Java

Node.js

PHP

Python

Metadatos de la plantilla

¿Qué sigue?

Crea y administra plantillas