Verwenden einer Sperrliste

Achtung

Die Beispieldaten in diesem Leitfaden können anstößige Inhalte enthalten. Wir raten zu umsichtigem Vorgehen.

Die standardmäßigen KI-Klassifizierer reichen für die meisten Anforderungen an die Inhaltsmoderation aus. Allerdings müssen Sie eventuell auf Begriffe prüfen, die spezifisch für Ihren Anwendungsfall sind. Mit Blocklisten können Sie den KI-Klassifizierern benutzerdefinierte Ausdrücke hinzufügen. Sie können Blocklisten verwenden, um nach bestimmten Begriffen oder Ausdrücken zu suchen, die Sie in Ihren Inhalten kennzeichnen möchten.

Voraussetzungen

Azure-Abonnement: Kostenloses Azure-Konto
Sobald Sie über ein Azure-Abonnement verfügen, können Sie im Azure-Portal eine Content Safety-Ressource erstellen, um Ihren Schlüssel und Endpunkt abzurufen. Geben Sie einen eindeutigen Namen für Ihre Ressource ein, wählen Sie Ihr Abonnement aus, und wählen Sie dann eine Ressourcengruppe, eine unterstützte Region (weitere Informationen unter Regionale Verfügbarkeit) und einen unterstützten Tarif aus. Wählen Sie dann Erstellen aus.
- Die Bereitstellung der Ressource dauert einige Minuten. Wählen Sie im Anschluss Zu Ressource wechseln aus. Wählen Sie im linken Bereich unter Ressourcenverwaltung die Option Abonnementschlüssel und Endpunkt aus. Der Endpunkt und einer der Schlüssel werden verwendet, um APIs aufzurufen.
Installation einer der folgenden Optionen:
- cURL für REST-API-Aufrufe
- Installation von Python 3.x
  - Ihre Python-Installation sollte pip enthalten. Sie können überprüfen, ob pip installiert ist, indem Sie pip --version in der Befehlszeile ausführen. Installieren Sie die aktuelle Python-Version, um pip zu erhalten.
  - Wenn Sie Python verwenden, müssen Sie die Azure AI Content Safety-Clientbibliothek für Python installieren. Führen Sie in Ihrem Projektverzeichnis den Befehl pip install azure-ai-contentsafety aus.
- .NET Runtime installiert.
  - Installation des .NET Core SDK
  - Wenn Sie .NET verwenden, müssen Sie die Azure AI Content Safety-Clientbibliothek für .NET installieren. Führen Sie in Ihrem Projektverzeichnis den Befehl dotnet add package Azure.AI.ContentSafety --prerelease aus.

Erstellen von Umgebungsvariablen

In diesem Beispiel schreiben Sie Ihre Anmeldeinformationen in Umgebungsvariablen auf dem lokalen Computer, auf dem die Anwendung ausgeführt wird.

Um die Umgebungsvariable für Ihren Ressourcenschlüssel und Endpunkt festzulegen, öffnen Sie ein Konsolenfenster und befolgen Sie die Anweisungen für Ihr Betriebssystem und Ihre Entwicklungsumgebung.

Zum Festlegen der Umgebungsvariablen CONTENT_SAFETY_KEY ersetzen Sie YOUR_CONTENT_SAFETY_KEY durch einen der Schlüssel für Ihre Ressource.
Zum Festlegen der Umgebungsvariablen CONTENT_SAFETY_ENDPOINT ersetzen Sie YOUR_CONTENT_SAFETY_ENDPOINT durch den Endpunkt für Ihre Ressource.

Wichtig

Verwenden Sie API-Schlüssel mit Vorsicht. Fügen Sie den API-Schlüssel nicht direkt in Ihren Code ein, und machen Sie ihn nicht öffentlich zugänglich. Wenn Sie einen API-Schlüssel verwenden, speichern Sie ihn in Azure Key Vault. Weitere Informationen zur sicheren Verwendung von API-Schlüsseln in Ihren Apps finden Sie unter API-Schlüssel mit Azure Key Vault.

Weitere Informationen zur Sicherheit von KI Services finden Sie unter Authentifizieren von Anforderungen an Azure KI Services.

Windows
Linux

setx CONTENT_SAFETY_KEY 'YOUR_CONTENT_SAFETY_KEY'

setx CONTENT_SAFETY_ENDPOINT 'YOUR_CONTENT_SAFETY_ENDPOINT'

Nach dem Hinzufügen der Umgebungsvariablen müssen Sie möglicherweise alle ausgeführten Programme neu starten, die die Umgebungsvariablen lesen, z. B. das Konsolenfenster.

export CONTENT_SAFETY_KEY='YOUR_CONTENT_SAFETY_KEY'

export CONTENT_SAFETY_ENDPOINT='YOUR_CONTENT_SAFETY_ENDPOINT'

Führen Sie nach dem Hinzufügen der Umgebungsvariablen im Konsolenfenster source ~/.bashrc aus, damit die Änderungen wirksam werden.

Analysieren von Text mit einer Sperrliste

Sie können Sperrlisten für die Verwendung mit der Text-API erstellen. Die folgenden Schritte helfen Ihnen bei den ersten Schritten.

Erstellen oder Ändern einer Sperrliste

Kopieren Sie den nachstehenden cURL-Befehl in einen Text-Editor, und nehmen Sie folgende Änderungen vor:

Ersetzen Sie <endpoint> durch Ihre Endpunkt-URL.
Ersetzen Sie <enter_your_key_here> durch Ihren Schlüssel.
Ersetzen Sie (in der URL) <your_list_name> durch einen benutzerdefinierten Namen für Ihre Liste. Ersetzen Sie außerdem den letzten Begriff der REST-URL durch denselben Namen. Zulässige Zeichen: 0–9, A-Z, a-z, - . _ ~.
Ersetzen Sie optional den Wert des Felds "description" durch eine benutzerdefinierte Beschreibung.

curl --location --request PATCH '<endpoint>/contentsafety/text/blocklists/<your_list_name>?api-version=2024-09-01' \
--header 'Ocp-Apim-Subscription-Key: <enter_your_key_here>' \
--header 'Content-Type: application/json' \
--data-raw '{
    "description": "This is a violence list"
}'

Der Antwortcode sollte 201 (neue Liste erstellt) oder 200 (vorhandene Liste aktualisiert) sein.

Erstellen Sie eine neue C#-Konsolen-App, und öffnen Sie sie in Ihrem bevorzugten Editor oder Ihrer integrierten Entwicklungsumgebung (IDE). Fügen Sie den folgenden Code ein.

string endpoint = Environment.GetEnvironmentVariable("CONTENT_SAFETY_ENDPOINT");
string key = Environment.GetEnvironmentVariable("CONTENT_SAFETY_KEY");

BlocklistClient blocklistClient = new BlocklistClient(new Uri(endpoint), new AzureKeyCredential(key));

var blocklistName = "<your_list_name>";
var blocklistDescription = "<description>";

var data = new
{
    description = blocklistDescription,
};

var createResponse = blocklistClient.CreateOrUpdateTextBlocklist(blocklistName, RequestContent.Create(data));

if (createResponse.Status == 201)
{
    Console.WriteLine("\nBlocklist {0} created.", blocklistName);
}
else if (createResponse.Status == 200)
{
    Console.WriteLine("\nBlocklist {0} updated.", blocklistName);
}

Ersetzen Sie <your_list_name> durch einen benutzerdefinierten Namen für Ihre Liste. Zulässige Zeichen: 0-9, A-Z, a-z, - . _ ~
Ersetzen Sie <description> optional durch eine benutzerdefinierte Beschreibung.
Führen Sie den Code aus.

Erstellen Sie eine Java-Anwendung, und öffnen Sie sie in Ihrem bevorzugten Editor oder Ihrer bevorzugten IDE. Fügen Sie den folgenden Code ein.

String endpoint = Configuration.getGlobalConfiguration().get("CONTENT_SAFETY_ENDPOINT");
String key = Configuration.getGlobalConfiguration().get("CONTENT_SAFETY_KEY");
BlocklistClient blocklistClient = new BlocklistClientBuilder()
        .credential(new KeyCredential(key))
        .endpoint(endpoint).buildClient();

String blocklistName = "<your_list_name>";


Map<String, String> description = new HashMap<>();
description.put("description", "<description>");
BinaryData resource = BinaryData.fromObject(description);
RequestOptions requestOptions = new RequestOptions();
Response<BinaryData> response =
        blocklistClient.createOrUpdateTextBlocklistWithResponse(blocklistName, resource, requestOptions);
if (response.getStatusCode() == 201) {
    System.out.println("\nBlocklist " + blocklistName + " created.");
} else if (response.getStatusCode() == 200) {
    System.out.println("\nBlocklist " + blocklistName + " updated.");
}

Ersetzen Sie <your_list_name> durch einen benutzerdefinierten Namen für Ihre Liste. Zulässige Zeichen: 0-9, A-Z, a-z, - . _ ~
Ersetzen Sie <description> optional durch eine benutzerdefinierte Beschreibung.
Führen Sie den Code aus.

Erstellen Sie ein neues Python-Skript, und öffnen Sie es in Ihrem bevorzugten Editor oder Ihrer bevorzugten IDE. Fügen Sie den folgenden Code ein.

import os
from azure.ai.contentsafety import BlocklistClient
from azure.core.credentials import AzureKeyCredential
from azure.ai.contentsafety.models import TextBlocklist
from azure.core.exceptions import HttpResponseError

key = os.environ["CONTENT_SAFETY_KEY"]
endpoint = os.environ["CONTENT_SAFETY_ENDPOINT"]
  
# Create a Blocklist client
client = BlocklistClient(endpoint, AzureKeyCredential(key))

blocklist_name = "<your_list_name>"
blocklist_description = "<description>"

try:
    blocklist = client.create_or_update_text_blocklist(
        blocklist_name=blocklist_name,
        options=TextBlocklist(blocklist_name=blocklist_name, description=blocklist_description),
    )
    if blocklist:
        print("\nBlocklist created or updated: ")
        print(f"Name: {blocklist.blocklist_name}, Description: {blocklist.description}")
except HttpResponseError as e:
    print("\nCreate or update text blocklist failed: ")
    if e.error:
        print(f"Error code: {e.error.code}")
        print(f"Error message: {e.error.message}")
        raise
    print(e)
    raise

Ersetzen Sie <your_list_name> durch einen benutzerdefinierten Namen für Ihre Liste. Zulässige Zeichen: 0-9, A-Z, a-z, - . _ ~
Ersetzen Sie <description> durch eine benutzerdefinierte Beschreibung.
Führen Sie das Skript aus.

Erstellen Sie ein neues JavaScript-Skript, und öffnen Sie es in Ihrem bevorzugten Editor oder Ihrer bevorzugten IDE. Fügen Sie den folgenden Code ein.

const ContentSafetyClient = require("@azure-rest/ai-content-safety").default,
  { isUnexpected } = require("@azure-rest/ai-content-safety");
const { AzureKeyCredential } = require("@azure/core-auth");

// Load the .env file if it exists
require("dotenv").config();

const endpoint = process.env["CONTENT_SAFETY_ENDPOINT"] || "<endpoint>";
const key = process.env["CONTENT_SAFETY_API_KEY"] || "<key>";

const credential = new AzureKeyCredential(key);
const client = ContentSafetyClient(endpoint, credential);

async function createOrUpdateTextBlocklist() {
  const blocklistName = "<your_list_name>";
  const blocklistDescription = "<description>";

  const createOrUpdateTextBlocklistParameters = {
    contentType: "application/merge-patch+json",
    body: {
      description: blocklistDescription,
    },
  };

  const result = await client
    .path("/text/blocklists/{blocklistName}", blocklistName)
    .patch(createOrUpdateTextBlocklistParameters);

  if (isUnexpected(result)) {
    throw result;
  }

  console.log(
    "Blocklist created or updated. Name: ",
    result.body.blocklistName,
    ", Description: ",
    result.body.description
  );
}

(async () => {
  await createOrUpdateTextBlocklist();
})().catch((err) => {
  console.error("The sample encountered an error:", err);
});

Ersetzen Sie <your_list_name> durch einen benutzerdefinierten Namen für Ihre Liste. Zulässige Zeichen: 0-9, A-Z, a-z, - . _ ~
Ersetzen Sie <description> optional durch eine benutzerdefinierte Beschreibung.
Führen Sie das Skript aus.

Hinzufügen von blocklistItems zur Liste

Hinweis

Für alle Listen gilt eine Obergrenze von insgesamt 10.000 Begriffen. Sie können in einer Anforderung maximal 100 blocklistItems hinzufügen.

Kopieren Sie den nachstehenden cURL-Befehl in einen Text-Editor, und nehmen Sie folgende Änderungen vor:

Ersetzen Sie <endpoint> durch Ihre Endpunkt-URL.
Ersetzen Sie <enter_your_key_here> durch Ihren Schlüssel.
Ersetzen Sie <your_list_name> (in der URL) durch den Namen, den Sie im Schritt zur Listenerstellung verwendet haben.
Ersetzen Sie optional den Wert des Felds "description" durch eine benutzerdefinierte Beschreibung.
Ersetzen Sie den Wert des Felds "text" durch den Begriff, den Sie Ihrer Sperrliste hinzufügen möchten. Ein blocklistItems darf maximal 128 Zeichen lang sein.

curl --location --request POST '<endpoint>/contentsafety/text/blocklists/<your_list_name>:addOrUpdateBlocklistItems?api-version=2024-09-01' \
--header 'Ocp-Apim-Subscription-Key: <enter_your_key_here>' \
--header 'Content-Type: application/json' \
--data-raw '{"blocklistItems": [{
    "description": "string",
    "text": "bleed"
}]}'

Tipp

Sie können in einem API-Aufruf mehrere blocklistItems hinzufügen. Legen Sie den Anforderungstext als JSON-Array von Datengruppen fest:

{
   "blocklistItems": [
       {
           "description": "string",
           "text": "bleed"
       },
       {
           "description": "string",
           "text": "blood"
       }
   ]
}

Der Antwortcode muss 200 sein.

{
"blocklistItems:"[
  {
  "blocklistItemId": "string",
  "description": "string",
  "text": "bleed"
  
   }
 ]
}

Erstellen Sie eine neue C#-Konsolen-App, und öffnen Sie sie in Ihrem bevorzugten Editor oder Ihrer integrierten Entwicklungsumgebung (IDE). Fügen Sie den folgenden Code ein.

string endpoint = Environment.GetEnvironmentVariable("CONTENT_SAFETY_ENDPOINT");
string key = Environment.GetEnvironmentVariable("CONTENT_SAFETY_KEY");
BlocklistClient blocklistClient = new BlocklistClient(new Uri(endpoint), new AzureKeyCredential(key));

var blocklistName = "<your_list_name>";


string blocklistItemText1 = "<block_item_text_1>";
string blocklistItemText2 = "<block_item_text_2>";

var blocklistItems = new TextBlocklistItem[] { new TextBlocklistItem(blocklistItemText1), new TextBlocklistItem(blocklistItemText2) };
var addedBlocklistItems = blocklistClient.AddOrUpdateBlocklistItems(blocklistName, new AddOrUpdateTextBlocklistItemsOptions(blocklistItems));

if (addedBlocklistItems != null && addedBlocklistItems.Value != null)
{
    Console.WriteLine("\nBlocklistItems added:");
    foreach (var addedBlocklistItem in addedBlocklistItems.Value.BlocklistItems)
    {
        Console.WriteLine("BlocklistItemId: {0}, Text: {1}, Description: {2}", addedBlocklistItem.BlocklistItemId, addedBlocklistItem.Text, addedBlocklistItem.Description);
    }
}

Ersetzen Sie <your_list_name> durch den Namen, den Sie im Schritt zur Listenerstellung verwendet haben.
Ersetzen Sie die Werte der Felder blocklistItemText1 und blocklistItemText2 durch die Elemente, die Sie Ihrer Sperrliste hinzufügen möchten. Ein blockItem darf maximal 128 Zeichen lang sein.
Fügen Sie dem Parameter blockItems optional weitere blockItem-Zeichenfolgen hinzu.
Führen Sie den Code aus.

Erstellen Sie eine Java-Anwendung, und öffnen Sie sie in Ihrem bevorzugten Editor oder Ihrer bevorzugten IDE. Fügen Sie den folgenden Code ein.

String endpoint = Configuration.getGlobalConfiguration().get("CONTENT_SAFETY_ENDPOINT");
String key = Configuration.getGlobalConfiguration().get("CONTENT_SAFETY_KEY");
BlocklistClient blocklistClient = new BlocklistClientBuilder()
        .credential(new KeyCredential(key))
        .endpoint(endpoint).buildClient();

String blocklistName = "<your_list_name>";

String blockItemText1 = "<block_item_text_1>";
String blockItemText2 = "<block_item_text_2>";
List<TextBlocklistItem> blockItems = Arrays.asList(new TextBlocklistItem(blockItemText1).setDescription("Kill word"),
        new TextBlocklistItem(blockItemText2).setDescription("Hate word"));
AddOrUpdateTextBlocklistItemsResult addedBlockItems = blocklistClient.addOrUpdateBlocklistItems(blocklistName,
        new AddOrUpdateTextBlocklistItemsOptions(blockItems));
if (addedBlockItems != null && addedBlockItems.getBlocklistItems() != null) {
    System.out.println("\nBlockItems added:");
    for (TextBlocklistItem addedBlockItem : addedBlockItems.getBlocklistItems()) {
        System.out.println("BlockItemId: " + addedBlockItem.getBlocklistItemId() + ", Text: " + addedBlockItem.getText() + ", Description: " + addedBlockItem.getDescription());
    }
}

Ersetzen Sie <your_list_name> durch den Namen, den Sie im Schritt zur Listenerstellung verwendet haben.
Ersetzen Sie die Werte der Felder blockItemText1 und blockItemText2 durch die Elemente, die Sie Ihrer Sperrliste hinzufügen möchten. Ein blockItem darf maximal 128 Zeichen lang sein.
Fügen Sie dem Parameter blockItems optional weitere blockItem-Zeichenfolgen hinzu.
Führen Sie den Code aus.

Erstellen Sie ein neues Python-Skript, und öffnen Sie es in Ihrem bevorzugten Editor oder Ihrer bevorzugten IDE. Fügen Sie den folgenden Code ein.

import os
from azure.ai.contentsafety import BlocklistClient
from azure.core.credentials import AzureKeyCredential
from azure.ai.contentsafety.models import (
    AddOrUpdateTextBlocklistItemsOptions, TextBlocklistItem
)
from azure.core.exceptions import HttpResponseError

key = os.environ["CONTENT_SAFETY_KEY"]
endpoint = os.environ["CONTENT_SAFETY_ENDPOINT"]

# Create a Blocklist client
client = BlocklistClient(endpoint, AzureKeyCredential(key))

blocklist_name = "<your_list_name>"
blocklist_item_text_1 = "<block_item_text_1>"
blocklist_item_text_2 = "<block_item_text_2>"

blocklist_items = [TextBlocklistItem(text=blocklist_item_text_1), TextBlocklistItem(text=blocklist_item_text_2)]
try:
    result = client.add_or_update_blocklist_items(
        blocklist_name=blocklist_name, options=AddOrUpdateTextBlocklistItemsOptions(blocklist_items=blocklist_items))
    for blocklist_item in result.blocklist_items:
        print(
            f"BlocklistItemId: {blocklist_item.blocklist_item_id}, Text: {blocklist_item.text}, Description: {blocklist_item.description}"
        )
except HttpResponseError as e:
    print("\nAdd blocklistItems failed: ")
    if e.error:
        print(f"Error code: {e.error.code}")
        print(f"Error message: {e.error.message}")
        raise
    print(e)
    raise

Ersetzen Sie <your_list_name> durch den Namen, den Sie im Schritt zur Listenerstellung verwendet haben.
Ersetzen Sie die Werte der Felder blocklist_item_text_1 und blocklist_item_text_2 durch die Elemente, die Sie Ihrer Sperrliste hinzufügen möchten. Ein blockItem darf maximal 128 Zeichen lang sein.
Fügen Sie dem Parameter block_items optional weitere blockItem-Zeichenfolgen hinzu.
Führen Sie das Skript aus.

const ContentSafetyClient = require("@azure-rest/ai-content-safety").default,
  { isUnexpected } = require("@azure-rest/ai-content-safety");
const { AzureKeyCredential } = require("@azure/core-auth");

// Load the .env file if it exists
require("dotenv").config();

const endpoint = process.env["CONTENT_SAFETY_ENDPOINT"] || "<endpoint>";
const key = process.env["CONTENT_SAFETY_API_KEY"] || "<key>";

const credential = new AzureKeyCredential(key);
const client = ContentSafetyClient(endpoint, credential);

async function addBlocklistItems() {
  const blocklistName = "<your_list_name>";
  const blocklistItemText1 = "<block_item_text_1>";
  const blocklistItemText2 = "<block_item_text_2>";
  const addOrUpdateBlocklistItemsParameters = {
    body: {
      blocklistItems: [
        {
          description: "Test blocklist item 1",
          text: blocklistItemText1,
        },
        {
          description: "Test blocklist item 2",
          text: blocklistItemText2,
        },
      ],
    },
  };

  const result = await client
    .path("/text/blocklists/{blocklistName}:addOrUpdateBlocklistItems", blocklistName)
    .post(addOrUpdateBlocklistItemsParameters);

  if (isUnexpected(result)) {
    throw result;
  }

  console.log("Blocklist items added: ");
  if (result.body.blocklistItems) {
    for (const blocklistItem of result.body.blocklistItems) {
      console.log(
        "BlocklistItemId: ",
        blocklistItem.blocklistItemId,
        ", Text: ",
        blocklistItem.text,
        ", Description: ",
        blocklistItem.description
      );
    }
  }
}
(async () => {
  await addBlocklistItems();
})().catch((err) => {
  console.error("The sample encountered an error:", err);
});

Ersetzen Sie <your_list_name> durch den Namen, den Sie im Schritt zur Listenerstellung verwendet haben.
Ersetzen Sie die Werte der Felder block_item_text_1 und block_item_text_2 durch die Elemente, die Sie Ihrer Sperrliste hinzufügen möchten. Ein blockItem darf maximal 128 Zeichen lang sein.
Fügen Sie dem Parameter blocklistItems optional weitere blockItem-Zeichenfolgen hinzu.
Führen Sie das Skript aus.

Hinweis

Nachdem Sie ein blockItem hinzugefügt oder bearbeitet haben, gibt es eine gewisse Verzögerung, ehe es sich auf die Textanalyse auswirkt, die normalerweise länger als fünf Minuten dauert.

Analysieren von Text mit einer Sperrliste

Kopieren Sie den nachstehenden cURL-Befehl in einen Text-Editor, und nehmen Sie folgende Änderungen vor:

Ersetzen Sie <endpoint> durch Ihre Endpunkt-URL.
Ersetzen Sie <enter_your_key_here> durch Ihren Schlüssel.
Ersetzen Sie <your_list_name> durch den Namen, den Sie im Schritt zur Listenerstellung verwendet haben. Das Feld "blocklistNames" kann ein Array mit mehreren Listen-IDs enthalten.
Ändern Sie optional den Wert von "breakByBlocklists". true gibt an, dass die Analyse sofort ohne Modellausgabe zurückkehrt, sobald eine Sperrliste gefunden wurde. false bewirkt, dass das Modell weiterhin Analysen in den Standardkategorien durchführt.
Ändern Sie optional den Wert des Felds "text" in einen beliebigen Text, den Sie analysieren möchten.

curl --location --request POST '<endpoint>/contentsafety/text:analyze?api-version=2024-09-01&' \
--header 'Ocp-Apim-Subscription-Key: <enter_your_key_here>' \
--header 'Content-Type: application/json' \
--data-raw '{
  "text": "I want to beat you till you bleed",
  "categories": [
    "Hate",
    "Sexual",
    "SelfHarm",
    "Violence"
  ],
  "blocklistNames":["<your_list_name>"],
  "haltOnBlocklistHit": false,
  "outputType": "FourSeverityLevels"
}'

Die JSON-Antwort enthält ein "blocklistMatchResults" mit allen Übereinstimmungen mit Ihrer Sperrliste. Sie meldet die Position in der Textzeichenfolge, an der die Übereinstimmung gefunden wurde.

{
  "blocklistsMatch": [
    {
      "blocklistName": "string",
      "blocklistItemId": "string",
      "blocklistItemText": "bleed"
    }
  ],
  "categoriesAnalysis": [
    {
      "category": "Hate",
      "severity": 0
    }
  ]
}

Erstellen Sie eine neue C#-Konsolen-App, und öffnen Sie sie in Ihrem bevorzugten Editor oder Ihrer integrierten Entwicklungsumgebung (IDE). Fügen Sie den folgenden Code ein.

string endpoint = Environment.GetEnvironmentVariable("CONTENT_SAFETY_ENDPOINT");
string key = Environment.GetEnvironmentVariable("CONTENT_SAFETY_KEY");
ContentSafetyClient client = new ContentSafetyClient(new Uri(endpoint), new AzureKeyCredential(key));

var blocklistName = "<your_list_name>";

// After you edit your blocklist, it usually takes effect in 5 minutes, please wait some time before analyzing with blocklist after editing.
var request = new AnalyzeTextOptions("<your_input_text>");
request.BlocklistNames.Add(blocklistName);
request.HaltOnBlocklistHit  = true;

Response<AnalyzeTextResult> response;
try
{
    response = client.AnalyzeText(request);
}
catch (RequestFailedException ex)
{
    Console.WriteLine("Analyze text failed.\nStatus code: {0}, Error code: {1}, Error message: {2}", ex.Status, ex.ErrorCode, ex.Message);
    throw;
}

if (response.Value.BlocklistsMatch != null)
{
    Console.WriteLine("\nBlocklist match result:");
    foreach (var matchResult in response.Value.BlocklistsMatch)
    {
        Console.WriteLine("BlocklistName: {0}, BlocklistItemId: {1}, BlocklistText: {2}, ", matchResult.BlocklistName, matchResult.BlocklistItemId, matchResult.BlocklistItemText);
    }
}

Ersetzen Sie <your_list_name> durch den Namen, den Sie im Schritt zur Listenerstellung verwendet haben.
Ersetzen Sie den Eingabetext request durch den Text, den Sie analysieren möchten.
Führen Sie das Skript aus.

Erstellen Sie eine Java-Anwendung, und öffnen Sie sie in Ihrem bevorzugten Editor oder Ihrer bevorzugten IDE. Fügen Sie den folgenden Code ein.

String endpoint = Configuration.getGlobalConfiguration().get("CONTENT_SAFETY_ENDPOINT");
String key = Configuration.getGlobalConfiguration().get("CONTENT_SAFETY_KEY");

ContentSafetyClient contentSafetyClient = new ContentSafetyClientBuilder()
        .credential(new KeyCredential(key))
        .endpoint(endpoint).buildClient();

String blocklistName = "<your_list_name>";

AnalyzeTextOptions request = new AnalyzeTextOptions("<sample_text>");
request.setBlocklistNames(Arrays.asList(blocklistName));
request.setHaltOnBlocklistHit(true);

AnalyzeTextResult analyzeTextResult;
try {
    analyzeTextResult = contentSafetyClient.analyzeText(request);
} catch (HttpResponseException ex) {
    System.out.println("Analyze text failed.\nStatus code: " + ex.getResponse().getStatusCode() + ", Error message: " + ex.getMessage());
    throw ex;
}

if (analyzeTextResult.getBlocklistsMatch() != null) {
    System.out.println("\nBlocklist match result:");
    for (TextBlocklistMatch matchResult : analyzeTextResult.getBlocklistsMatch()) {
        System.out.println("BlocklistName: " + matchResult.getBlocklistName() + ", BlockItemId: " + matchResult.getBlocklistItemId() + ", BlockItemText: " + matchResult.getBlocklistItemText());
    }
}

Ersetzen Sie <your_list_name> durch den Namen, den Sie im Schritt zur Listenerstellung verwendet haben.
Ersetzen Sie den Eingabetext request durch den Text, den Sie analysieren möchten.
Führen Sie das Skript aus.

Erstellen Sie ein neues Python-Skript, und öffnen Sie es in Ihrem bevorzugten Editor oder Ihrer bevorzugten IDE. Fügen Sie den folgenden Code ein.

import os
from azure.ai.contentsafety import ContentSafetyClient
from azure.core.credentials import AzureKeyCredential
from azure.ai.contentsafety.models import AnalyzeTextOptions
from azure.core.exceptions import HttpResponseError

key = os.environ["CONTENT_SAFETY_KEY"]
endpoint = os.environ["CONTENT_SAFETY_ENDPOINT"]

# Create a Content Safety client
client = ContentSafetyClient(endpoint, AzureKeyCredential(key))

blocklist_name = "<your_list_name>"
input_text = "<your_input_text>"

try:
    # After you edit your blocklist, it usually takes effect in 5 minutes, please wait some time before analyzing
    # with blocklist after editing.
    analysis_result = client.analyze_text(
        AnalyzeTextOptions(text=input_text, blocklist_names=[blocklist_name], halt_on_blocklist_hit=False)
    )
    if analysis_result and analysis_result.blocklists_match:
        print("\nBlocklist match results: ")
        for match_result in analysis_result.blocklists_match:
            print(
                f"BlocklistName: {match_result.blocklist_name}, BlocklistItemId: {match_result.blocklist_item_id}, "
                f"BlocklistItemText: {match_result.blocklist_item_text}"
            )
except HttpResponseError as e:
    print("\nAnalyze text failed: ")
    if e.error:
        print(f"Error code: {e.error.code}")
        print(f"Error message: {e.error.message}")
        raise
    print(e)
    raise

Ersetzen Sie <your_list_name> durch den Namen, den Sie im Schritt zur Listenerstellung verwendet haben.
Ersetzen Sie die Variable input_text durch Text, den Sie analysieren möchten.
Führen Sie das Skript aus.

const ContentSafetyClient = require("@azure-rest/ai-content-safety").default,
  { isUnexpected } = require("@azure-rest/ai-content-safety");
const { AzureKeyCredential } = require("@azure/core-auth");

// Load the .env file if it exists
require("dotenv").config();

const endpoint = process.env["CONTENT_SAFETY_ENDPOINT"] || "<endpoint>";
const key = process.env["CONTENT_SAFETY_API_KEY"] || "<key>";

const credential = new AzureKeyCredential(key);
const client = ContentSafetyClient(endpoint, credential);

async function analyzeTextWithBlocklists() {
  const blocklistName = "<your_list_name>";
  const inputText = "<your_input_text>";
  const analyzeTextParameters = {
    body: {
      text: inputText,
      blocklistNames: [blocklistName],
      haltOnBlocklistHit: false,
    },
  };

  const result = await client.path("/text:analyze").post(analyzeTextParameters);

  if (isUnexpected(result)) {
    throw result;
  }

  console.log("Blocklist match results: ");
  if (result.body.blocklistsMatch) {
    for (const blocklistMatchResult of result.body.blocklistsMatch) {
      console.log(
        "BlocklistName: ",
        blocklistMatchResult.blocklistName,
        ", BlocklistItemId: ",
        blocklistMatchResult.blocklistItemId,
        ", BlocklistItemText: ",
        blocklistMatchResult.blocklistItemText
      );
    }
  }
}

(async () => {
  await analyzeTextWithBlocklists();
})().catch((err) => {
  console.error("The sample encountered an error:", err);
});

Ersetzen Sie <your_list_name> durch den Namen, den Sie im Schritt zur Listenerstellung verwendet haben.
Ersetzen Sie die Variable inputText durch Text, den Sie analysieren möchten.
Führen Sie das Skript aus.

Andere Sperrlistenvorgänge

Dieser Abschnitt enthält weitere Vorgänge, die Ihnen bei der Verwaltung und Verwendung des Features „Sperrliste“ helfen.

Auflisten aller blocklistItems in einer Liste

Kopieren Sie den nachstehenden cURL-Befehl in einen Text-Editor, und nehmen Sie folgende Änderungen vor:

Ersetzen Sie <endpoint> durch Ihre Endpunkt-URL.
Ersetzen Sie <enter_your_key_here> durch Ihren Schlüssel.
Ersetzen Sie <your_list_name> (in der Anforderungs-URL) durch den Namen, den Sie im Schritt zur Listenerstellung verwendet haben.

curl --location --request GET '<endpoint>/contentsafety/text/blocklists/<your_list_name>/blocklistItems?api-version=2024-09-01' \
--header 'Ocp-Apim-Subscription-Key: <enter_your_key_here>' \
--header 'Content-Type: application/json'

Der Statuscode sollte200 sein und der Antworttext wie folgt aussehen:

{
 "values": [
  {
   "blocklistItemId": "string",
   "description": "string",
   "text": "bleed",
  }
 ]
}

Erstellen Sie eine neue C#-Konsolen-App, und öffnen Sie sie in Ihrem bevorzugten Editor oder Ihrer integrierten Entwicklungsumgebung (IDE). Fügen Sie den folgenden Code ein.

string endpoint = Environment.GetEnvironmentVariable("CONTENT_SAFETY_ENDPOINT");
string key = Environment.GetEnvironmentVariable("CONTENT_SAFETY_KEY");
BlocklistClient blocklistClient = new BlocklistClient(new Uri(endpoint), new AzureKeyCredential(key));

var blocklistName = "<your_list_name>";

var allBlocklistitems = blocklistClient.GetTextBlocklistItems(blocklistName);
Console.WriteLine("\nList BlocklistItems:");
foreach (var blocklistItem in allBlocklistitems)
{
    Console.WriteLine("BlocklistItemId: {0}, Text: {1}, Description: {2}", blocklistItem.BlocklistItemId, blocklistItem.Text, blocklistItem.Description);
}

Ersetzen Sie <your_list_name> durch den Namen, den Sie im Schritt zur Listenerstellung verwendet haben.
Führen Sie das Skript aus.

Erstellen Sie eine Java-Anwendung, und öffnen Sie sie in Ihrem bevorzugten Editor oder Ihrer bevorzugten IDE. Fügen Sie den folgenden Code ein.

String endpoint = Configuration.getGlobalConfiguration().get("CONTENT_SAFETY_ENDPOINT");
String key = Configuration.getGlobalConfiguration().get("CONTENT_SAFETY_KEY");
BlocklistClient blocklistClient = new BlocklistClientBuilder()
        .credential(new KeyCredential(key))
        .endpoint(endpoint).buildClient();

String blocklistName = "<your_list_name>";

PagedIterable<TextBlocklistItem> allBlockitems = blocklistClient.listTextBlocklistItems(blocklistName);
System.out.println("\nList BlockItems:");
for (TextBlocklistItem blocklistItem : allBlockitems) {
    System.out.println("BlockItemId: " + blocklistItem.getBlocklistItemId() + ", Text: " + blocklistItem.getText() + ", Description: " + blocklistItem.getDescription());
}

Ersetzen Sie <your_list_name> durch den Namen, den Sie im Schritt zur Listenerstellung verwendet haben.
Führen Sie das Skript aus.

Erstellen Sie ein neues Python-Skript, und öffnen Sie es in Ihrem bevorzugten Editor oder Ihrer bevorzugten IDE. Fügen Sie den folgenden Code ein.

import os
from azure.ai.contentsafety import BlocklistClient
from azure.core.credentials import AzureKeyCredential
from azure.core.exceptions import HttpResponseError

key = os.environ["CONTENT_SAFETY_KEY"]
endpoint = os.environ["CONTENT_SAFETY_ENDPOINT"]

# Create a Blocklist client
client = BlocklistClient(endpoint, AzureKeyCredential(key))

blocklist_name = "<your_list_name>"

try:
    blocklist_items = client.list_text_blocklist_items(blocklist_name=blocklist_name)
    if blocklist_items:
        print("\nList blocklist items: ")
        for blocklist_item in blocklist_items:
            print(
                f"BlocklistItemId: {blocklist_item.blocklist_item_id}, Text: {blocklist_item.text}, "
                f"Description: {blocklist_item.description}"
            )
except HttpResponseError as e:
    print("\nList blocklist items failed: ")
    if e.error:
        print(f"Error code: {e.error.code}")
        print(f"Error message: {e.error.message}")
        raise
    print(e)
    raise

Ersetzen Sie <your_list_name> durch den Namen, den Sie im Schritt zur Listenerstellung verwendet haben.
Führen Sie das Skript aus.

const ContentSafetyClient = require("@azure-rest/ai-content-safety").default,
  { isUnexpected } = require("@azure-rest/ai-content-safety");
const { AzureKeyCredential } = require("@azure/core-auth");

// Load the .env file if it exists
require("dotenv").config();

const endpoint = process.env["CONTENT_SAFETY_ENDPOINT"] || "<endpoint>";
const key = process.env["CONTENT_SAFETY_API_KEY"] || "<key>";

const credential = new AzureKeyCredential(key);
const client = ContentSafetyClient(endpoint, credential);

async function listBlocklistItems() {
  const blocklistName = "<your_list_name>";

  const result = await client
    .path("/text/blocklists/{blocklistName}/blocklistItems", blocklistName)
    .get();

  if (isUnexpected(result)) {
    throw result;
  }

  console.log("List blocklist items: ");
  if (result.body.value) {
    for (const blocklistItem of result.body.value) {
      console.log(
        "BlocklistItemId: ",
        blocklistItem.blocklistItemId,
        ", Text: ",
        blocklistItem.text,
        ", Description: ",
        blocklistItem.description
      );
    }
  }
}

(async () => {
  await listBlocklistItems();
})().catch((err) => {
  console.error("The sample encountered an error:", err);
});

Ersetzen Sie <your_list_name> durch den Namen, den Sie im Schritt zur Listenerstellung verwendet haben.
Führen Sie das Skript aus.

Auflisten aller Sperrlisten

Kopieren Sie den nachstehenden cURL-Befehl in einen Text-Editor, und nehmen Sie folgende Änderungen vor:

Ersetzen Sie <endpoint> durch Ihre Endpunkt-URL.
Ersetzen Sie <enter_your_key_here> durch Ihren Schlüssel.

curl --location --request GET '<endpoint>/contentsafety/text/blocklists?api-version=2024-09-01' \
--header 'Ocp-Apim-Subscription-Key: <enter_your_key_here>' \
--header 'Content-Type: application/json'

Der Statuscode sollte 200 lauten. Die JSON-Antwort sieht wie folgt aus:

"value": [
  {
    "blocklistName": "string",
    "description": "string"
  }
]

Erstellen Sie eine neue C#-Konsolen-App, und öffnen Sie sie in Ihrem bevorzugten Editor oder Ihrer integrierten Entwicklungsumgebung (IDE). Fügen Sie den folgenden Code ein.

string endpoint = Environment.GetEnvironmentVariable("CONTENT_SAFETY_ENDPOINT");
string key = Environment.GetEnvironmentVariable("CONTENT_SAFETY_KEY");
BlocklistClient blocklistClient = new BlocklistClient(new Uri(endpoint), new AzureKeyCredential(key));

var blocklists = blocklistClient.GetTextBlocklists();
Console.WriteLine("\nList blocklists:");
foreach (var blocklist in blocklists)
{
    Console.WriteLine("BlocklistName: {0}, Description: {1}", blocklist.Name, blocklist.Description);
}

Führen Sie das Skript aus.

Erstellen Sie eine Java-Anwendung, und öffnen Sie sie in Ihrem bevorzugten Editor oder Ihrer bevorzugten IDE. Fügen Sie den folgenden Code ein.

String endpoint = Configuration.getGlobalConfiguration().get("CONTENT_SAFETY_ENDPOINT");
String key = Configuration.getGlobalConfiguration().get("CONTENT_SAFETY_KEY");
BlocklistClient blocklistClient = new BlocklistClientBuilder()
        .credential(new KeyCredential(key))
        .endpoint(endpoint).buildClient();

PagedIterable<TextBlocklist> allTextBlocklists = blocklistClient.listTextBlocklists();
System.out.println("\nList Blocklist:");
for (TextBlocklist blocklist : allTextBlocklists) {
    System.out.println("Blocklist: " + blocklist.getName() + ", Description: " + blocklist.getDescription());
}

Führen Sie das Skript aus.

Erstellen Sie ein neues Python-Skript, und öffnen Sie es in Ihrem bevorzugten Editor oder Ihrer bevorzugten IDE. Fügen Sie den folgenden Code ein.

import os
from azure.ai.contentsafety import BlocklistClient
from azure.core.credentials import AzureKeyCredential
from azure.core.exceptions import HttpResponseError

key = os.environ["CONTENT_SAFETY_KEY"]
endpoint = os.environ["CONTENT_SAFETY_ENDPOINT"]

# Create a Blocklist client
client = BlocklistClient(endpoint, AzureKeyCredential(key))


try:
    blocklists = client.list_text_blocklists()
    if blocklists:
        print("\nList blocklists: ")
        for blocklist in blocklists:
            print(f"Name: {blocklist.blocklist_name}, Description: {blocklist.description}")
except HttpResponseError as e:
    print("\nList text blocklists failed: ")
    if e.error:
        print(f"Error code: {e.error.code}")
        print(f"Error message: {e.error.message}")
        raise
    print(e)
    raise

Führen Sie das Skript aus.

const ContentSafetyClient = require("@azure-rest/ai-content-safety").default,
  { isUnexpected } = require("@azure-rest/ai-content-safety");
const { AzureKeyCredential } = require("@azure/core-auth");

// Load the .env file if it exists
require("dotenv").config();

const endpoint = process.env["CONTENT_SAFETY_ENDPOINT"] || "<endpoint>";
const key = process.env["CONTENT_SAFETY_API_KEY"] || "<key>";

const credential = new AzureKeyCredential(key);
const client = ContentSafetyClient(endpoint, credential);

async function listTextBlocklists() {
  const result = await client.path("/text/blocklists").get();

  if (isUnexpected(result)) {
    throw result;
  }

  console.log("List blocklists: ");
  if (result.body.value) {
    for (const blocklist of result.body.value) {
      console.log(
        "BlocklistName: ",
        blocklist.blocklistName,
        ", Description: ",
        blocklist.description
      );
    }
  }
}

(async () => {
  await listTextBlocklists();
})().catch((err) => {
  console.error("The sample encountered an error:", err);
});

Führen Sie das Skript aus.

Abrufen einer Blockliste nach blocklistName

Kopieren Sie den nachstehenden cURL-Befehl in einen Text-Editor, und nehmen Sie folgende Änderungen vor:

Ersetzen Sie <endpoint> durch Ihre Endpunkt-URL.
Ersetzen Sie <enter_your_key_here> durch Ihren Schlüssel.
Ersetzen Sie <your_list_name> (in der Anforderungs-URL) durch den Namen, den Sie im Schritt zur Listenerstellung verwendet haben.

cURL --location '<endpoint>contentsafety/text/blocklists/<your_list_name>?api-version=2024-09-01' \
--header 'Ocp-Apim-Subscription-Key: <enter_your_key_here>' \
--data ''

Der Statuscode sollte 200 lauten. Die JSON-Antwort sieht wie folgt aus:

{
  "blocklistName": "string",
  "description": "string"
}

Erstellen Sie eine neue C#-Konsolen-App, und öffnen Sie sie in Ihrem bevorzugten Editor oder Ihrer integrierten Entwicklungsumgebung (IDE). Fügen Sie den folgenden Code ein.

string endpoint = Environment.GetEnvironmentVariable("CONTENT_SAFETY_ENDPOINT");
string key = Environment.GetEnvironmentVariable("CONTENT_SAFETY_KEY");
BlocklistClient blocklistClient = new BlocklistClient(new Uri(endpoint), new AzureKeyCredential(key));

var blocklistName = "<your_list_name>";

var getBlocklist = blocklistClient.GetTextBlocklist(blocklistName);
if (getBlocklist != null && getBlocklist.Value != null)
{
    Console.WriteLine("\nGet blocklist:");
    Console.WriteLine("BlocklistName: {0}, Description: {1}", getBlocklist.Value.Name, getBlocklist.Value.Description);
}

Ersetzen Sie <your_list_name> durch den Namen, den Sie im Schritt zur Listenerstellung verwendet haben.
Führen Sie das Skript aus.

Erstellen Sie eine Java-Anwendung, und öffnen Sie sie in Ihrem bevorzugten Editor oder Ihrer bevorzugten IDE. Fügen Sie den folgenden Code ein.

String endpoint = Configuration.getGlobalConfiguration().get("CONTENT_SAFETY_ENDPOINT");
String key = Configuration.getGlobalConfiguration().get("CONTENT_SAFETY_KEY");
BlocklistClient blocklistClient = new BlocklistClientBuilder()
        .credential(new KeyCredential(key))
        .endpoint(endpoint).buildClient();

String blocklistName = "<your_list_name>";

TextBlocklist getBlocklist = blocklistClient.getTextBlocklist(blocklistName);
if (getBlocklist != null) {
    System.out.println("\nGet blocklist:");
    System.out.println("BlocklistName: " + getBlocklist.getName() + ", Description: " + getBlocklist.getDescription());
}

Ersetzen Sie <your_list_name> durch den Namen, den Sie im Schritt zur Listenerstellung verwendet haben.
Führen Sie das Skript aus.

Erstellen Sie ein neues Python-Skript, und öffnen Sie es in Ihrem bevorzugten Editor oder Ihrer bevorzugten IDE. Fügen Sie den folgenden Code ein.

import os
from azure.ai.contentsafety import BlocklistClient
from azure.core.credentials import AzureKeyCredential
from azure.core.exceptions import HttpResponseError

key = os.environ["CONTENT_SAFETY_KEY"]
endpoint = os.environ["CONTENT_SAFETY_ENDPOINT"]

# Create a Blocklist client
client = BlocklistClient(endpoint, AzureKeyCredential(key))

blocklist_name = "<your_list_name>"

try:
    blocklist = client.get_text_blocklist(blocklist_name=blocklist_name)
    if blocklist:
        print("\nGet blocklist: ")
        print(f"Name: {blocklist.blocklist_name}, Description: {blocklist.description}")
except HttpResponseError as e:
    print("\nGet text blocklist failed: ")
    if e.error:
        print(f"Error code: {e.error.code}")
        print(f"Error message: {e.error.message}")
        raise
    print(e)
    raise

Ersetzen Sie <your_list_name> durch den Namen, den Sie im Schritt zur Listenerstellung verwendet haben.
Führen Sie das Skript aus.

const ContentSafetyClient = require("@azure-rest/ai-content-safety").default,
  { isUnexpected } = require("@azure-rest/ai-content-safety");
const { AzureKeyCredential } = require("@azure/core-auth");

// Load the .env file if it exists
require("dotenv").config();

const endpoint = process.env["CONTENT_SAFETY_ENDPOINT"] || "<endpoint>";
const key = process.env["CONTENT_SAFETY_API_KEY"] || "<key>";

const credential = new AzureKeyCredential(key);
const client = ContentSafetyClient(endpoint, credential);

async function getTextBlocklist() {
  const blocklistName = "<your_list_name>";

  const result = await client.path("/text/blocklists/{blocklistName}", blocklistName).get();

  if (isUnexpected(result)) {
    throw result;
  }

  console.log("Get blocklist: ");
  console.log("Name: ", result.body.blocklistName, ", Description: ", result.body.description);
}


(async () => {
  await getTextBlocklist();
})().catch((err) => {
  console.error("The sample encountered an error:", err);
});

Ersetzen Sie <your_list_name> durch den Namen, den Sie im Schritt zur Listenerstellung verwendet haben.
Führen Sie das Skript aus.

Abrufen eines blocklistItem nach blocklistName und blocklistItemId

Kopieren Sie den nachstehenden cURL-Befehl in einen Text-Editor, und nehmen Sie folgende Änderungen vor:

Ersetzen Sie <endpoint> durch Ihre Endpunkt-URL.
Ersetzen Sie <enter_your_key_here> durch Ihren Schlüssel.
Ersetzen Sie <your_list_name> (in der Anforderungs-URL) durch den Namen, den Sie im Schritt zur Listenerstellung verwendet haben.
Ersetzen Sie <your_item_id> durch den ID-Wert für das blocklistItem. Dies ist der Wert des Felds "blocklistItemId" aus den API-Aufrufen zum Hinzufügen von blocklistItem oder Abrufen aller blocklistItems.

cURL --location '<endpoint>contentsafety/text/blocklists/<your_list_name>/blocklistItems/<your_item_id>?api-version=2024-09-01' \
--header 'Ocp-Apim-Subscription-Key: <enter_your_key_here>' \
--data ''

Der Statuscode sollte 200 lauten. Die JSON-Antwort sieht wie folgt aus:

{
  "blocklistItemId": "string",
  "description": "string",
  "text": "string"
}

Erstellen Sie eine neue C#-Konsolen-App, und öffnen Sie sie in Ihrem bevorzugten Editor oder Ihrer integrierten Entwicklungsumgebung (IDE). Fügen Sie den folgenden Code ein.

string endpoint = Environment.GetEnvironmentVariable("CONTENT_SAFETY_ENDPOINT");
string key = Environment.GetEnvironmentVariable("CONTENT_SAFETY_KEY");
BlocklistClient blocklistClient = new BlocklistClient(new Uri(endpoint), new AzureKeyCredential(key));

var blocklistName = "<your_list_name>";
var getBlocklistItemId = "<your_block_item_id>";

var getBlocklistItem = blocklistClient.GetTextBlocklistItem(blocklistName, getBlocklistItemId);

Console.WriteLine("\nGet BlocklistItem:");
Console.WriteLine("BlocklistItemId: {0}, Text: {1}, Description: {2}", getBlocklistItem.Value.BlocklistItemId, getBlocklistItem.Value.Text, getBlocklistItem.Value.Description);

Ersetzen Sie <your_list_name> durch den Namen, den Sie im Schritt zur Listenerstellung verwendet haben.
Ersetzen Sie <your_block_item_id> durch die ID eines zuvor hinzugefügten Elements.
Führen Sie das Skript aus.

Erstellen Sie eine Java-Anwendung, und öffnen Sie sie in Ihrem bevorzugten Editor oder Ihrer bevorzugten IDE. Fügen Sie den folgenden Code ein.

String endpoint = Configuration.getGlobalConfiguration().get("CONTENT_SAFETY_ENDPOINT");
String key = Configuration.getGlobalConfiguration().get("CONTENT_SAFETY_KEY");
BlocklistClient blocklistClient = new BlocklistClientBuilder()
        .credential(new KeyCredential(key))
        .endpoint(endpoint).buildClient();

String blocklistName = "<your_list_name>";

String getBlockItemId = "<your_block_item_id>";

TextBlocklistItem getBlockItem = blocklistClient.getTextBlocklistItem(blocklistName, getBlockItemId);
System.out.println("\nGet BlockItem:");
System.out.println("BlockItemId: " + getBlockItem.getBlocklistItemId() + ", Text: " + getBlockItem.getText() + ", Description: " + getBlockItem.getDescription());

Ersetzen Sie <your_list_name> durch den Namen, den Sie im Schritt zur Listenerstellung verwendet haben.
Ersetzen Sie <your_block_item_id> durch die ID eines zuvor hinzugefügten Elements.
Führen Sie das Skript aus.

Erstellen Sie ein neues Python-Skript, und öffnen Sie es in Ihrem bevorzugten Editor oder Ihrer bevorzugten IDE. Fügen Sie den folgenden Code ein.

import os
from azure.ai.contentsafety import BlocklistClient
from azure.core.credentials import AzureKeyCredential
from azure.ai.contentsafety.models import TextBlocklistItem, AddOrUpdateTextBlocklistItemsOptions
from azure.core.exceptions import HttpResponseError

key = os.environ["CONTENT_SAFETY_KEY"]
endpoint = os.environ["CONTENT_SAFETY_ENDPOINT"]

# Create a Blocklist client
client = BlocklistClient(endpoint, AzureKeyCredential(key))

blocklist_name = "<your_list_name>"
blocklist_item_text_1 = "<block_item_text>"

try:
    # Add a blocklistItem
    add_result = client.add_or_update_blocklist_items(
        blocklist_name=blocklist_name,
        options=AddOrUpdateTextBlocklistItemsOptions(blocklist_items=[TextBlocklistItem(text=blocklist_item_text_1)]),
    )
    if not add_result or not add_result.blocklist_items or len(add_result.blocklist_items) <= 0:
        raise RuntimeError("BlocklistItem not created.")
    blocklist_item_id = add_result.blocklist_items[0].blocklist_item_id

    # Get this blocklistItem by blocklistItemId
    blocklist_item = client.get_text_blocklist_item(blocklist_name=blocklist_name, blocklist_item_id=blocklist_item_id)
    print("\nGet blocklistItem: ")
    print(
        f"BlocklistItemId: {blocklist_item.blocklist_item_id}, Text: {blocklist_item.text}, Description: {blocklist_item.description}"
    )
except HttpResponseError as e:
    print("\nGet blocklist item failed: ")
    if e.error:
        print(f"Error code: {e.error.code}")
        print(f"Error message: {e.error.message}")
        raise
    print(e)
    raise

Ersetzen Sie <your_list_name> durch den Namen, den Sie im Schritt zur Listenerstellung verwendet haben.
Ersetzen Sie <block_item_text> durch den Text des Blockelements.
Führen Sie das Skript aus.

const ContentSafetyClient = require("@azure-rest/ai-content-safety").default,
  { isUnexpected } = require("@azure-rest/ai-content-safety");
const { AzureKeyCredential } = require("@azure/core-auth");

// Load the .env file if it exists
require("dotenv").config();

const endpoint = process.env["CONTENT_SAFETY_ENDPOINT"] || "<endpoint>";
const key = process.env["CONTENT_SAFETY_API_KEY"] || "<key>";

const credential = new AzureKeyCredential(key);
const client = ContentSafetyClient(endpoint, credential);

async function getBlocklistItem() {
  const blocklistName = "<your_list_name>";

  const blocklistItemId = "<your_block_item_id>";

  // Get this blocklistItem by blocklistItemId
  const blocklistItem = await client
    .path(
      "/text/blocklists/{blocklistName}/blocklistItems/{blocklistItemId}",
      blocklistName,
      blocklistItemId
    )
    .get();

  if (isUnexpected(blocklistItem)) {
    throw blocklistItem;
  }

  console.log("Get blocklistitem: ");
  console.log(
    "BlocklistItemId: ",
    blocklistItem.body.blocklistItemId,
    ", Text: ",
    blocklistItem.body.text,
    ", Description: ",
    blocklistItem.body.description
  );
}


(async () => {
  await getBlocklistItem();
})().catch((err) => {
  console.error("The sample encountered an error:", err);
});

Ersetzen Sie <your_list_name> durch den Namen, den Sie im Schritt zur Listenerstellung verwendet haben.
Ersetzen Sie <your_block_item_id> durch die ID des Elements, das Sie abrufen möchten.
Führen Sie das Skript aus.

Entfernen Sie blocklistItems aus einer Blockliste.

Hinweis

Nachdem Sie ein Element gelöscht haben, gibt es eine gewisse Verzögerung, ehe sich der Vorgang auf die Textanalyse auswirkt, die normalerweise nicht länger als fünf Minuten dauert.

Kopieren Sie den nachstehenden cURL-Befehl in einen Text-Editor, und nehmen Sie folgende Änderungen vor:

Ersetzen Sie <endpoint> durch Ihre Endpunkt-URL.
Ersetzen Sie <enter_your_key_here> durch Ihren Schlüssel.
Ersetzen Sie <your_list_name> (in der Anforderungs-URL) durch den Namen, den Sie im Schritt zur Listenerstellung verwendet haben.
Ersetzen Sie <item_id> durch den ID-Wert für das blocklistItem. Dies ist der Wert des Felds "blocklistItemId" aus den API-Aufrufen zum Hinzufügen von blocklistItem oder Abrufen aller blocklistItems.

curl --location --request POST '<endpoint>/contentsafety/text/blocklists/<your_list_name>:removeBlocklistItems?api-version=2024-09-01' \
--header 'Ocp-Apim-Subscription-Key: <enter_your_key_here>' \
--header 'Content-Type: application/json'
--data-raw '{"blocklistItemIds":[
    "<item_id>"
]}'

Tipp

Sie können mehrere blocklistItem in einem API-Aufruf löschen. Legen Sie den Anforderungstext als Array von blocklistItemId-Werten fest.

Der Antwortcode muss 204 sein.

Erstellen Sie eine neue C#-Konsolen-App, und öffnen Sie sie in Ihrem bevorzugten Editor oder Ihrer integrierten Entwicklungsumgebung (IDE). Fügen Sie den folgenden Code ein.

string endpoint = os.environ["CONTENT_SAFETY_ENDPOINT"];
string key = os.environ["CONTENT_SAFETY_KEY"];
BlocklistClient blocklistClient = new BlocklistClient(new Uri(endpoint), new AzureKeyCredential(key));

var blocklistName = "<your_list_name>";

var removeBlocklistItemId = "<your_block_item_id>";
var removeBlocklistItemIds = new List<string> { removeBlocklistItemId };
var removeResult = blocklistClient.RemoveBlocklistItems(blocklistName, new RemoveTextBlocklistItemsOptions(removeBlocklistItemIds));

if (removeResult != null && removeResult.Status == 204)
{
    Console.WriteLine("\nBlocklistItem removed: {0}.", removeBlocklistItemId);
}

Ersetzen Sie <your_list_name> durch den Namen, den Sie im Schritt zur Listenerstellung verwendet haben.
Ersetzen Sie <your_block_item_id> durch die ID eines zuvor hinzugefügten Elements.
Führen Sie das Skript aus.

Erstellen Sie eine Java-Anwendung, und öffnen Sie sie in Ihrem bevorzugten Editor oder Ihrer bevorzugten IDE. Fügen Sie den folgenden Code ein.

String endpoint = Configuration.getGlobalConfiguration().get("CONTENT_SAFETY_ENDPOINT");
String key = Configuration.getGlobalConfiguration().get("CONTENT_SAFETY_KEY");
BlocklistClient blocklistClient = new BlocklistClientBuilder()
        .credential(new KeyCredential(key))
        .endpoint(endpoint).buildClient();

String blocklistName = "<your_list_name>";

String removeBlockItemId = "<your_block_item_id>";

List<String> removeBlockItemIds = new ArrayList<>();
removeBlockItemIds.add(removeBlockItemId);
blocklistClient.removeBlocklistItems(blocklistName, new RemoveTextBlocklistItemsOptions(removeBlockItemIds));

Ersetzen Sie <your_list_name> durch den Namen, den Sie im Schritt zur Listenerstellung verwendet haben.
Ersetzen Sie <your_block_item_id> durch die ID eines zuvor hinzugefügten Elements.
Führen Sie das Skript aus.

Erstellen Sie ein neues Python-Skript, und öffnen Sie es in Ihrem bevorzugten Editor oder Ihrer bevorzugten IDE. Fügen Sie den folgenden Code ein.

import os
from azure.ai.contentsafety import BlocklistClient
from azure.core.credentials import AzureKeyCredential
from azure.ai.contentsafety.models import (
    TextBlocklistItem,
    AddOrUpdateTextBlocklistItemsOptions,
    RemoveTextBlocklistItemsOptions,
)
from azure.core.exceptions import HttpResponseError

key = os.environ["CONTENT_SAFETY_KEY"]
endpoint = os.environ["CONTENT_SAFETY_ENDPOINT"]

# Create a Blocklist client
client = BlocklistClient(endpoint, AzureKeyCredential(key))

blocklist_name = "<your_list_name>"
blocklist_item_text_1 = "<block_item_text>"

try:
    # Add a blocklistItem
    add_result = client.add_or_update_blocklist_items(
        blocklist_name=blocklist_name,
        options=AddOrUpdateTextBlocklistItemsOptions(blocklist_items=[TextBlocklistItem(text=blocklist_item_text_1)]),
    )
    if not add_result or not add_result.blocklist_items or len(add_result.blocklist_items) <= 0:
        raise RuntimeError("BlocklistItem not created.")
    blocklist_item_id = add_result.blocklist_items[0].blocklist_item_id

    # Remove this blocklistItem by blocklistItemId
    client.remove_blocklist_items(
        blocklist_name=blocklist_name, options=RemoveTextBlocklistItemsOptions(blocklist_item_ids=[blocklist_item_id])
    )
    print(f"\nRemoved blocklistItem: {add_result.blocklist_items[0].blocklist_item_id}")
except HttpResponseError as e:
    print("\nRemove blocklist item failed: ")
    if e.error:
        print(f"Error code: {e.error.code}")
        print(f"Error message: {e.error.message}")
        raise
    print(e)
    raise

Ersetzen Sie <your_list_name> durch den Namen, den Sie im Schritt zur Listenerstellung verwendet haben. Ersetzen Sie <block_item_text> durch den Text des Blockelements.
Führen Sie das Skript aus.

const ContentSafetyClient = require("@azure-rest/ai-content-safety").default,
  { isUnexpected } = require("@azure-rest/ai-content-safety");
const { AzureKeyCredential } = require("@azure/core-auth");

// Load the .env file if it exists
require("dotenv").config();

const endpoint = process.env["CONTENT_SAFETY_ENDPOINT"] || "<endpoint>";
const key = process.env["CONTENT_SAFETY_API_KEY"] || "<key>";

const credential = new AzureKeyCredential(key);
const client = ContentSafetyClient(endpoint, credential);

// Sample: Remove blocklistItems from a blocklist
async function removeBlocklistItems() {
  const blocklistName = "<your_list_name>";

  const blocklistItemId = "<your_block_item_id>";

  // Remove this blocklistItem by blocklistItemId
  const removeBlocklistItemsParameters = {
    body: {
      blocklistItemIds: [blocklistItemId],
    },
  };
  const removeBlocklistItem = await client
    .path("/text/blocklists/{blocklistName}:removeBlocklistItems", blocklistName)
    .post(removeBlocklistItemsParameters);

  if (isUnexpected(removeBlocklistItem)) {
    throw removeBlocklistItem;
  }

  console.log("Removed blocklistItem: ", blocklistItemText);
}


(async () => {
  await removeBlocklistItems();
})().catch((err) => {
  console.error("The sample encountered an error:", err);
});

Ersetzen Sie <your_list_name> durch den Namen, den Sie im Schritt zur Listenerstellung verwendet haben. Ersetzen Sie <your_block_item_id durch die ID des Elements, das Sie entfernen möchten.
Führen Sie das Skript aus.

Löschen einer Liste und ihres gesamten Inhalts

Hinweis

Nachdem Sie eine Liste gelöscht haben, gibt es eine gewisse Verzögerung, ehe es sich dieser Vorgang auf die Textanalyse auswirkt, die normalerweise nicht länger als fünf Minuten dauert.

Kopieren Sie den nachstehenden cURL-Befehl in einen Text-Editor, und nehmen Sie folgende Änderungen vor:

Ersetzen Sie <endpoint> durch Ihre Endpunkt-URL.
Ersetzen Sie <enter_your_key_here> durch Ihren Schlüssel.
Ersetzen Sie <your_list_name> (in der Anforderungs-URL) durch den Namen, den Sie im Schritt zur Listenerstellung verwendet haben.

curl --location --request DELETE '<endpoint>/contentsafety/text/blocklists/<your_list_name>?api-version=2024-09-01' \
--header 'Ocp-Apim-Subscription-Key: <enter_your_key_here>' \
--header 'Content-Type: application/json' \

Der Antwortcode muss 204 sein.

Erstellen Sie eine neue C#-Konsolen-App, und öffnen Sie sie in Ihrem bevorzugten Editor oder Ihrer integrierten Entwicklungsumgebung (IDE). Fügen Sie den folgenden Code ein.

string endpoint = os.environ["CONTENT_SAFETY_ENDPOINT"];
string key = os.environ["CONTENT_SAFETY_KEY"];
BlocklistClient blocklistClient = new BlocklistClient(new Uri(endpoint), new AzureKeyCredential(key));

var blocklistName = "<your_list_name>";

var deleteResult = blocklistClient.DeleteTextBlocklist(blocklistName);
if (deleteResult != null && deleteResult.Status == 204)
{
    Console.WriteLine("\nDeleted blocklist.");
}

Ersetzen Sie <your_list_name> (in der Anforderungs-URL) durch den Namen, den Sie im Schritt zur Listenerstellung verwendet haben.
Führen Sie das Skript aus.

Erstellen Sie eine Java-Anwendung, und öffnen Sie sie in Ihrem bevorzugten Editor oder Ihrer bevorzugten IDE. Fügen Sie den folgenden Code ein.

String endpoint = Configuration.getGlobalConfiguration().get("CONTENT_SAFETY_ENDPOINT");
String key = Configuration.getGlobalConfiguration().get("CONTENT_SAFETY_KEY");
BlocklistClient blocklistClient = new BlocklistClientBuilder()
        .credential(new KeyCredential(key))
        .endpoint(endpoint).buildClient();

String blocklistName = "<your_list_name>";

blocklistClient.deleteTextBlocklist(blocklistName);

Ersetzen Sie <your_list_name> (in der Anforderungs-URL) durch den Namen, den Sie im Schritt zur Listenerstellung verwendet haben.
Führen Sie das Skript aus.

Erstellen Sie ein neues Python-Skript, und öffnen Sie es in Ihrem bevorzugten Editor oder Ihrer bevorzugten IDE. Fügen Sie den folgenden Code ein.

import os
from azure.ai.contentsafety import BlocklistClient
from azure.core.credentials import AzureKeyCredential
from azure.core.exceptions import HttpResponseError

key = os.environ["CONTENT_SAFETY_KEY"]
endpoint = os.environ["CONTENT_SAFETY_ENDPOINT"]

# Create a Blocklist client
client = BlocklistClient(endpoint, AzureKeyCredential(key))

blocklist_name = "<your_list_name>"

try:
    client.delete_text_blocklist(blocklist_name=blocklist_name)
    print(f"\nDeleted blocklist: {blocklist_name}")
except HttpResponseError as e:
    print("\nDelete blocklist failed:")
    if e.error:
        print(f"Error code: {e.error.code}")
        print(f"Error message: {e.error.message}")
        raise
    print(e)
    raise

Ersetzen Sie <your_list_name> (in der Anforderungs-URL) durch den Namen, den Sie im Schritt zur Listenerstellung verwendet haben.
Führen Sie das Skript aus.

const ContentSafetyClient = require("@azure-rest/ai-content-safety").default,
  { isUnexpected } = require("@azure-rest/ai-content-safety");
const { AzureKeyCredential } = require("@azure/core-auth");

// Load the .env file if it exists
require("dotenv").config();

const endpoint = process.env["CONTENT_SAFETY_ENDPOINT"] || "<endpoint>";
const key = process.env["CONTENT_SAFETY_API_KEY"] || "<key>";

const credential = new AzureKeyCredential(key);
const client = ContentSafetyClient(endpoint, credential);

async function deleteBlocklist() {
  const blocklistName = "<your_list_name>";

  const result = await client.path("/text/blocklists/{blocklistName}", blocklistName).delete();

  if (isUnexpected(result)) {
    throw result;
  }

  console.log("Deleted blocklist: ", blocklistName);
}


(async () => {
  await deleteBlocklist();
})().catch((err) => {
  console.error("The sample encountered an error:", err);
});

Ersetzen Sie <your_list_name> (in der Anforderungs-URL) durch den Namen, den Sie im Schritt zur Listenerstellung verwendet haben.
Führen Sie das Skript aus.

Nächste Schritte

Weitere Informationen zu den in dieser Anleitung verwendeten APIs finden Sie in der API-Referenzdokumentation.

Referenz zur Content Safety-API

Feedback

War diese Seite hilfreich?

Last updated on 2025-09-02

Freigeben über

Verwenden einer Sperrliste

Voraussetzungen

Erstellen von Umgebungsvariablen

Analysieren von Text mit einer Sperrliste

Erstellen oder Ändern einer Sperrliste

Hinzufügen von blocklistItems zur Liste

Analysieren von Text mit einer Sperrliste

Andere Sperrlistenvorgänge

Auflisten aller blocklistItems in einer Liste

Auflisten aller Sperrlisten

Abrufen einer Blockliste nach blocklistName

Abrufen eines blocklistItem nach blocklistName und blocklistItemId

Entfernen Sie blocklistItems aus einer Blockliste.

Löschen einer Liste und ihres gesamten Inhalts

Nächste Schritte

Feedback

Zusätzliche Ressourcen