Google utilise la technologie IA pour traduire le contenu dans votre langue préférée. Les traductions générées par IA peuvent contenir des erreurs.

Créer et gérer des modèles

Les modèles Model Armor permettent de configurer le filtrage des requêtes et des réponses pour vos applications d'IA. Les modèles fournissent des filtres et des seuils personnalisés pour plusieurs catégories de sécurité. Ce document explique comment créer et gérer des modèles Model Armor. Pour en savoir plus, consultez Modèles Model Armor.

Utiliser un point de terminaison régional ou multirégional

Lorsque vous utilisez un modèle Model Armor, vous devez utiliser un point de terminaison régional ou multirégional (modelarmor.LOCATION.rep.googleapis.com) correspondant à l'emplacement du modèle.

Le point de terminaison mondial (modelarmor.googleapis.com) n'est pas compatible avec la gestion des modèles Model Armor ni avec la désinfection des requêtes et des réponses.

Avant de commencer

Avant de commencer, effectuez les tâches suivantes.

Obtenir les autorisations requises

Pour obtenir les autorisations nécessaires pour gérer les modèles Model Armor, demandez à votre administrateur de vous accorder le rôle IAM Administrateur Model Armor (roles/modelarmor.admin) sur les modèles Model Armor. Pour en savoir plus sur l'attribution de rôles, consultez Gérer l'accès aux projets, aux dossiers et aux organisations.

Vous pouvez également obtenir les autorisations requises avec des rôles personnalisés ou d'autres rôles prédéfinis.

Activer les API

Vous devez activer l'API Model Armor avant de pouvoir utiliser Model Armor.

Console

Activez l'API Model Armor.
Rôles requis pour activer les API
Pour activer les API, vous devez disposer de l'autorisation serviceusage.services.enable. Si vous avez créé le projet, vous disposez probablement déjà de cette autorisation grâce au rôle Propriétaire (roles/owner). Sinon, vous pouvez obtenir cette autorisation grâce au rôle Administrateur Service Usage (roles/serviceusage.serviceUsageAdmin). Découvrez comment attribuer des rôles.
Activer l'API
Sélectionnez le projet dans lequel vous souhaitez activer Model Armor.

gcloud

Avant de commencer, suivez ces étapes à l'aide de la Google Cloud CLI avec l'API Model Armor :

Dans la console Google Cloud , activez Cloud Shell.

Activer Cloud Shell

En bas de la console Google Cloud , une session Cloud Shell démarre et affiche une invite de ligne de commande. Cloud Shell est un environnement shell dans lequel Google Cloud CLI est déjà installé, et dans lequel des valeurs sont déjà définies pour votre projet actuel. L'initialisation de la session peut prendre quelques secondes.
Définissez le remplacement du point de terminaison de l'API à l'aide de la gcloud CLI.

Définir le remplacement du point de terminaison de l'API à l'aide de la gcloud CLI

Cette étape n'est requise que si vous utilisez la gcloud CLI avec Model Armor et que vous souhaitez utiliser une région ou une multirégion autre que la multirégion us par défaut. Vous devez définir manuellement le remplacement du point de terminaison de l'API pour vous assurer que la gcloud CLI achemine correctement les requêtes vers le service Model Armor.

Exécutez la commande suivante pour définir le point de terminaison de l'API pour le service Model Armor.

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

Remplacez LOCATION par la région ou la multirégion dans laquelle vous souhaitez utiliser Model Armor.

Créer un modèle Model Armor

Les modèles Model Armor définissent les filtres et les seuils spécifiques que Model Armor utilise pour analyser les requêtes et les réponses afin de détecter les risques de sécurité. Pour créer un modèle Model Armor :

Console

Dans la console Google Cloud , accédez à la page Model Armor.

Accéder à Model Armor
Vérifiez que vous consultez le projet pour lequel vous avez activé Model Armor.
Sur la page Model Armor, cliquez sur Créer un modèle. La page Créer un modèle s'affiche.
Spécifiez l'ID du modèle. L'ID du modèle peut contenir des lettres, des chiffres, des traits de soulignement ou des traits d'union. Il ne peut pas comporter plus de 63 caractères, contenir d'espaces ni commencer par un trait d'union.
Dans la section Type d'emplacement, sélectionnez une région ou une multirégion dans laquelle les opérations Model Armor s'exécuteront. Vous ne pourrez plus modifier l'emplacement par la suite.
Facultatif : Dans la section Conformité à la résidence des données, choisissez d'activer ou non l'application de la résidence des données. Par défaut, toute fonctionnalité Model Armor qui n'est pas hébergée localement dans l'emplacement sélectionné est désactivée pour empêcher vos données de transiter vers d'autres juridictions. Les fonctionnalités désactivées sont listées dans cette section.

Vous pouvez activer les fonctionnalités restreintes par l'application de la résidence des données en désactivant l'option Appliquer la résidence des données. Cette action permet le routage transjuridictionnel de vos données.

Attention : Le routage transjuridictionnel de vos données peut avoir un impact sur la conformité de leur résidence.
Facultatif : Dans la section Libellés, ajoutez les paires clé-valeur que vous souhaitez utiliser pour regrouper les modèles associés.
Dans la section Version du filtre, sélectionnez le numéro ou l'alias de la version du filtre.
Sélectionnez la modalité pour indiquer si vous souhaitez filtrer le texte, les images ou les deux.

Remarque : Seuls les ensembles multirégionaux us et eu sont compatibles avec la modalité image. Si vous sélectionnez une autre région, le champ Sélectionner la modalité est désactivé.
Dans la section Détections, configurez les paramètres de détection.
Facultatif : Si vous sélectionnez la détection Sensitive Data Protection, vous devez configurer les paramètres Sensitive Data Protection.
Dans la section IA responsable, définissez le niveau de confiance pour chaque filtre de contenu.

Remarque : Si vous ne spécifiez pas de niveau de confiance, il est défini sur Élevé par défaut.
Facultatif : Développez la section Configurations supplémentaires (facultatif) et configurez l'un des paramètres suivants :
- Dans la section Configurer la journalisation, sélectionnez les opérations pour lesquelles vous souhaitez configurer la journalisation.
- Dans la section Compatibilité multilingue, sélectionnez Activer la compatibilité multilingue pour utiliser la détection multilingue.
- Dans la section Mode d'application, sélectionnez un type d'application.
Cliquez sur Créer.

gcloud

Exécutez la commande ci-dessous.

 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

Remplacez les éléments suivants :

LOCATION : emplacement du modèle.
TEMPLATE_ID : ID du modèle.
PROJECT_ID : ID du projet auquel appartient le modèle.

REST

Utilisez la commande suivante pour créer un modèle Model Armor.

  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"

Remplacez les éléments suivants :

FILTER_CONFIG : configuration du filtre pour le modèle au format JSON.
PROJECT_ID : ID du projet auquel appartient le modèle.
TEMPLATE_ID : ID du modèle à créer.
LOCATION : emplacement du modèle.

L'exemple suivant montre la configuration du filtre Model Armor (FilterConfig), où vous définissez ce que vous souhaitez détecter. Dans cet exemple, les filtres d'IA responsable sont configurés pour l'incitation à la haine, le harcèlement, les contenus dangereux et les contenus à caractère sexuel explicite avec différents niveaux de confiance. Le filtre Détection d'injection de prompt et de jailbreaking est activé avec un niveau de confiance HIGH, ce qui signifie que seuls les contenus présentant une probabilité élevée seront signalés. Le filtre URI malveillant est activé.

  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"

Pour définir la façon dont Model Armor gère les opérations, les erreurs et les journaux, définissez les métadonnées du modèle (TemplateMetadata) dans votre commande. Les métadonnées du modèle incluent des paramètres pour la détection de la langue, les modalités et la conformité de la résidence des données.

L'exemple suivant crée une configuration de modèle Model Armor avec la détection multilingue et les modalités (image et texte) activées.

  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#

Pour exécuter ce code, commencez par configurer un environnement de développement C# et installez le SDK Model Armor pour C#.

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

Pour exécuter ce code, commencez par configurer un environnement de développement Go et installez le SDK Model Armor pour Go.


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

Pour exécuter ce code, commencez par configurer un environnement de développement Java et installez le SDK Model Armor pour Java.


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

Pour exécuter ce code, commencez par configurer un environnement de développement Node.js, puis installez le SDK Model Armor pour Node.js.

/**
 * 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

Pour exécuter ce code, commencez par configurer un environnement de développement PHP et installez le SDK Model Armor pour PHP.

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

Pour exécuter ce code, commencez par configurer un environnement de développement Python et installez le SDK Model Armor pour Python.


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

Définir la conformité à la résidence des données

Par défaut, tout modèle que vous créez applique strictement la conformité à la résidence des données. Autrement dit, toute fonctionnalité Model Armor qui n'est pas hébergée dans la juridiction couvrant la région du modèle est désactivée. L'application de la conformité à la résidence des données empêche vos données de quitter leur juridiction.

Pour les modèles qui privilégient le filtrage complet de la sécurité par rapport à la résidence stricte des données, vous pouvez désactiver l'application de la résidence des données pour les données en cours d'utilisation et en transit. Pour ce faire, désactivez l'option Appliquer la résidence des données dans la consoleGoogle Cloud ou définissez data_residency_compliant sur false dans l'API Model Armor. Vos données au repos restent conformes à la résidence des données, quel que soit l'état de cette option.

Lorsque vous désactivez la conformité à la résidence des données dans un modèle, vous autorisez le routage transjuridictionnel de vos données. Autrement dit, Model Armor peut acheminer les requêtes vers d'autres juridictions lorsque des fonctionnalités spécifiques ne sont pas disponibles localement dans la juridiction du modèle.

Si vous désactivez la conformité de la résidence des données, toutes les fonctionnalités de Model Armor seront activées, à l'exception de la modalité d'image, qui restera limitée aux régions multirégionales us et eu.

Sélectionner une version du filtre

Les versions de filtre Model Armor offrent un équilibre entre la stabilité pour les charges de travail de production et l'accès aux modèles de détection des menaces mis à jour. Vous configurez la version du filtre au niveau du modèle. La version du filtre s'applique à tous les filtres du modèle, à l'exception de ceux listés dans Filtres qui n'utilisent pas de versions de filtre. Pour en savoir plus, consultez Définir la version du filtre pour un modèle.

Sélectionner une modalité

Utilisez la modalité pour spécifier si vous souhaitez analyser les éléments suivants :

Tout : analyse le texte et les images.
Modalités spécifiques :
- Texte : analyse les chaînes de texte et le texte intégré dans les formats de fichiers compatibles.
- Image : analyse les images.

Pour en savoir plus, consultez Filtrer les images et Assainir les requêtes contenant des images.

Configurer les détections

Les détections sont les vérifications spécifiques que Model Armor effectue sur les requêtes et les réponses. Model Armor offre un système flexible pour configurer les détections, ce qui vous permet d'adapter le niveau de protection de vos applications d'IA. Vous configurez les détections lorsque vous créez des modèles. Model Armor effectue les vérifications de détection suivantes sur les requêtes et les réponses :

Détection des URL malveillantes : identifie les adresses Web (URL) conçues pour nuire aux utilisateurs ou aux systèmes. Ces URL peuvent mener à des sites d'hameçonnage, des téléchargements de logiciels malveillants ou d'autres cyberattaques. Pour en savoir plus, consultez Détection des URL malveillantes.
Détection de l'injection de prompt et du jailbreaking : détecte les contenus malveillants et les tentatives de jailbreaking dans un prompt. Nous vous recommandons de définir le niveau de confiance sur Élevé pour minimiser les faux positifs et assurer un comportement de détection cohérent. Même si vous définissez le niveau de confiance sur Élevé, ce qui réduit le taux de faux positifs, vous pouvez toujours en observer dans de rares cas. Pour en savoir plus, consultez Détection de l'injection de prompt et du jailbreaking.
Protection des données sensibles : détecte les données sensibles et aide à prévenir leur exposition accidentelle à des attaques telles que l'injection de prompts. Pour en savoir plus, consultez Sensitive Data Protection.

Définir les paramètres de Sensitive Data Protection

Model Armor s'appuie sur la protection des données sensibles pour identifier et empêcher l'exposition d'informations sensibles dans vos interactions avec les LLM. Pour en savoir plus, consultez Sensitive Data Protection.

Model Armor propose deux modes pour configurer Sensitive Data Protection :

De base : approche plus simple qui utilise des infoTypes prédéfinis pour détecter les données sensibles. Pour en savoir plus sur l'infoType prédéfini, consultez Configuration de base de Sensitive Data Protection.
Avancée : option plus configurable qui utilise un modèle d'inspection défini dans le service Sensitive Data Protection comme source unique pour les infoTypes correspondant à des données sensibles.

Si vous sélectionnez le mode Avancé, vous devez spécifier les paramètres suivants :

Modèles d'inspection : modèles permettant d'enregistrer les informations de configuration associées aux tâches d'analyse d'inspection, y compris les détecteurs prédéfinis ou personnalisés qui doivent être utilisés. Saisissez le nom du modèle au format suivant : projects/projectId/locations/locationId/inspectTemplates/templateName
Facultatif : Modèle d'anonymisation : modèles permettant d'enregistrer les informations de configuration associées aux tâches d'anonymisation, y compris les transformations d'ensembles de données structurés et d'infoTypes. Saisissez un identifiant pour le modèle d'anonymisation au format suivant : projects/projectId/locations/locationId/deidentifyTemplates/templateName

Vérifiez que le modèle d'inspection et le modèle d'anonymisation existent dans Sensitive Data Protection. Si le modèle réside dans un autre projet, le rôle Utilisateur DLP (roles/dlp.user) et le rôle Lecteur DLP (roles/dlp.reader) doivent être attribués à l'agent de service Model Armor pour ce projet.

Définir le niveau de confiance

Le niveau de confiance indique la probabilité que les résultats correspondent à un type de filtre de contenu. Vous pouvez définir le niveau de confiance pour chaque filtre de contenu. Les valeurs possibles sont les suivantes :

Aucun : aucun contenu n'est détecté.
Faible et plus : le contenu est détecté avec un niveau de confiance faible, moyen ou élevé.
Moyen et plus : le contenu est détecté avec un niveau de confiance moyen ou élevé.
Élevé : le contenu est détecté avec un niveau de confiance élevé.

Pour une application plus stricte, définissez le niveau de confiance sur Faible et plus afin de détecter la plupart des contenus qui correspondent à un type de filtre de contenu.

Pour activer la journalisation complète sur un modèle, consultez Journalisation des audits et de la plate-forme Model Armor.

Définir le type d'application pour les modèles

Pour configurer la façon dont Model Armor gère les détections, définissez le type d'application.

Dans le champ template_metadata de la configuration du modèle, définissez enforcement_type sur INSPECT_ONLY ou 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": {
      "enable_multi_language_detection": 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"

Remplacez les éléments suivants :

PROJECT_ID : ID du projet auquel appartient le modèle.
TEMPLATE_ID : ID du modèle à créer.
LOCATION : emplacement du modèle.

Afficher un modèle Model Armor

Affichez les modèles existants pour comprendre les configurations disponibles, et résoudre les problèmes liés au filtrage des requêtes et des réponses.

Console

Dans la console Google Cloud , accédez à la page Model Armor.

Accéder à Model Armor
Vérifiez que vous consultez le projet pour lequel vous avez activé Model Armor. La page Model Armor s'affiche et liste les modèles créés pour votre projet.
Cliquez sur un modèle de la liste pour afficher ses détails.

gcloud

Exécutez la commande ci-dessous.

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

Remplacez les éléments suivants :

LOCATION : emplacement du modèle.
TEMPLATE_ID : ID du modèle.
PROJECT_ID : ID du projet auquel appartient le modèle.

REST

Exécutez la commande suivante :

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"

Remplacez les éléments suivants :

PROJECT_ID : ID du projet auquel appartient le modèle.
TEMPLATE_ID : ID du modèle à afficher.
LOCATION : emplacement du modèle.

C#

Pour exécuter ce code, commencez par configurer un environnement de développement C# et installez le SDK Model Armor pour C#.

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

Pour exécuter ce code, commencez par configurer un environnement de développement Go et installez le SDK Model Armor pour Go.


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

Pour exécuter ce code, commencez par configurer un environnement de développement Java et installez le SDK Model Armor pour Java.


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

Pour exécuter ce code, commencez par configurer un environnement de développement Node.js, puis installez le SDK Model Armor pour Node.js.

/**
 * 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

Pour exécuter ce code, commencez par configurer un environnement de développement PHP et installez le SDK Model Armor pour PHP.

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

Pour exécuter ce code, commencez par configurer un environnement de développement Python et installez le SDK Model Armor pour Python.


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)

Mettre à jour un modèle Model Armor

Mettez régulièrement à jour vos modèles pour maintenir une posture de sécurité robuste et efficace pour vos applications d'IA.

Console

Dans la console Google Cloud , accédez à la page Model Armor.

Accéder à Model Armor
Vérifiez que vous consultez le projet pour lequel vous avez activé Model Armor. La page Model Armor s'affiche et liste les modèles créés pour votre organisation.
Dans la liste, cliquez sur le modèle que vous souhaitez modifier. La page Détails du modèle s'affiche.
Cliquez sur Modifier.
Mettez à jour les paramètres requis, puis cliquez sur Enregistrer.

gcloud

Pour modifier un modèle, exécutez la commande gcloud model-armor templates update et incluez les indicateurs pour les paramètres que vous souhaitez modifier.

Par exemple, la commande suivante met à jour les paramètres de filtre et les métadonnées d'un modèle :

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

Remplacez les éléments suivants :

TEMPLATE_ID : ID du modèle.
PROJECT_ID : ID du projet auquel appartient le modèle.
LOCATION : emplacement du modèle.

REST

Exécutez la commande suivante :

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"

Remplacez les éléments suivants :

PROJECT_ID : ID du projet auquel appartient le modèle.
LOCATION : emplacement du modèle.
TEMPLATE_ID : ID du modèle.
UPDATE_MASK : les champs à mettre à jour, tels que filterConfig et filterConfig.piAndJailbreakFilterSettings. Si vous laissez ce champ vide, l'ensemble de la configuration du filtre sera mis à jour.

Tous les autres champs sont immuables. Toute tentative de mise à jour d'autres champs (par exemple, le nom du modèle) génère une erreur.

C#

Pour exécuter ce code, commencez par configurer un environnement de développement C# et installez le SDK Model Armor pour C#.

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

Pour exécuter ce code, commencez par configurer un environnement de développement Go et installez le SDK Model Armor pour Go.


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

Pour exécuter ce code, commencez par configurer un environnement de développement Java et installez le SDK Model Armor pour Java.


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

Pour exécuter ce code, commencez par configurer un environnement de développement Node.js, puis installez le SDK Model Armor pour Node.js.

/**
 * 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

Pour exécuter ce code, commencez par configurer un environnement de développement PHP et installez le SDK Model Armor pour PHP.

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

Pour exécuter ce code, commencez par configurer un environnement de développement Python et installez le SDK Model Armor pour Python.


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)

Supprimer un modèle Model Armor

Supprimez un modèle lorsqu'il n'est plus utilisé, qu'il est remplacé par un nouveau modèle ou lorsque les règles de sécurité changent.

Console

Dans la console Google Cloud , accédez à la page Model Armor.

Accéder à Model Armor
Vérifiez que vous consultez le projet pour lequel vous avez activé Model Armor. La page Model Armor s'affiche et liste les modèles créés pour votre organisation.
Dans la liste, cliquez sur le modèle que vous souhaitez supprimer. La page Détails du modèle s'affiche.
Cliquez sur Supprimer. Une boîte de dialogue de confirmation s'affiche.
Saisissez le nom du modèle pour confirmer la suppression, puis cliquez sur Supprimer.

gcloud

Exécutez la commande ci-dessous.

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

Remplacez les éléments suivants :

LOCATION : emplacement du modèle.
TEMPLATE_ID : ID du modèle.
PROJECT_ID : ID du projet auquel appartient le modèle.

REST

Exécutez la commande suivante :

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"

Remplacez les éléments suivants :

PROJECT_ID : ID du projet auquel appartient le modèle.
LOCATION : emplacement du modèle.
TEMPLATE_ID : ID du modèle.

C#

Pour exécuter ce code, commencez par configurer un environnement de développement C# et installez le SDK Model Armor pour C#.

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

Pour exécuter ce code, commencez par configurer un environnement de développement Go et installez le SDK Model Armor pour Go.


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

Pour exécuter ce code, commencez par configurer un environnement de développement Java et installez le SDK Model Armor pour Java.


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

Pour exécuter ce code, commencez par configurer un environnement de développement Node.js, puis installez le SDK Model Armor pour Node.js.

/**
 * 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

Pour exécuter ce code, commencez par configurer un environnement de développement PHP et installez le SDK Model Armor pour PHP.

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

Pour exécuter ce code, commencez par configurer un environnement de développement Python et installez le SDK Model Armor pour Python.


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)

Métadonnées d'un modèle

Les métadonnées du modèle Model Armor vous aident à configurer le comportement de Model Armor, y compris la gestion des vérifications de sécurité, la gestion des exceptions et le comportement de journalisation.

Les métadonnées du modèle pour Model Armor incluent les champs suivants :

Métadonnées	Type	Valeur par défaut	Description
enforcement_type	Enum	`INSPECT_AND_BLOCK`	Définit le type d'application. Appliquez l'une des valeurs suivantes : `INSPECT_ONLY` : Model Armor inspecte les requêtes qui ne respectent pas les paramètres configurés, mais ne les bloque pas. `INSPECT_AND_BLOCK` : Model Armor bloque les requêtes qui ne respectent pas les paramètres configurés.
log_template_operations	Booléen	Faux	Active la journalisation des opérations de modèle.
log_sanitize_operations	Booléen	Faux	Active la journalisation des opérations de nettoyage.
multiLanguageDetection	Booléen	Faux	Active la détection multilingue.
modalities (bêta)	Enum	Vide	Détermine si le texte, les images ou les deux doivent être analysés. Si vous laissez ce champ vide, seul le texte sera analysé. Appliquez l'une des valeurs suivantes : `TEXT` : analyse les chaînes de texte et le texte intégré dans les formats de fichier compatibles. `IMAGE` : analyse les images.
data_residency_compliant	Booléen	Vrai	Indique si le modèle est soumis à une conformité stricte en matière de résidence des données (traitement dans la juridiction). `True` : désactive les fonctionnalités qui ne sont pas compatibles localement dans la juridiction de la région de votre modèle pour empêcher les données de quitter la juridiction locale. `False` : désactive les vérifications de conformité de la résidence des données et permet le routage transjuridictionnel de vos données lorsqu'une fonctionnalité n'est pas disponible localement dans la juridiction. Pour en savoir plus sur ce champ, consultez Définir la conformité de la résidence des données dans ce document. Pour en savoir plus sur la résidence des données pour les modèles, consultez Application de la résidence des données pour les modèles.

Étapes suivantes

En savoir plus sur la présentation de Model Armor
En savoir plus sur les paramètres de plancher Model Armor
Nettoyez les requêtes et les réponses.
Résoudre les problèmes liés à Model Armor

Créer et gérer des modèles Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Utiliser un point de terminaison régional ou multirégional

Avant de commencer

Obtenir les autorisations requises

Activer les API

Console

gcloud

Définir le remplacement du point de terminaison de l'API à l'aide de la gcloud CLI

Créer un modèle Model Armor

Console

gcloud

REST

C#

Go

Java

Node.js

PHP

Python

Définir la conformité à la résidence des données

Sélectionner une version du filtre

Sélectionner une modalité

Configurer les détections

Définir les paramètres de Sensitive Data Protection

Définir le niveau de confiance

Définir le type d'application pour les modèles

Afficher un modèle Model Armor

Console

gcloud

REST

C#

Go

Java

Node.js

PHP

Python

Mettre à jour un modèle Model Armor

Console

gcloud

REST

C#

Go

Java

Node.js

PHP

Python

Supprimer un modèle Model Armor

Console

gcloud

REST

C#

Go

Java

Node.js

PHP

Python

Métadonnées d'un modèle

Étapes suivantes

Créer et gérer des modèles