Erkennen vertraulicher Daten mithilfe von Azure KI

2025-04-30

In diesem Artikel werden die vorab gesendete E-Mail-Analyse beschrieben, die vertrauliche Daten und unangemessene Inhalte mithilfe von Azure AI erkennt.

Mithilfe von Azure Communication Services-E-Mails können Organisationen Nachrichten mit hohem Volumen mithilfe ihrer Anwendungen an ihre Kunden senden. In diesem Lernprogramm wird gezeigt, wie Sie Azure AI verwenden, um sicherzustellen, dass Ihre Nachrichten die Marke und den Ruf Ihres Unternehmens genau widerspiegeln, bevor Sie sie senden. Azure KI bietet Dienste, um Ihre E-Mail-Inhalte auf vertrauliche Daten zu analysieren und unangemessene Inhalte zu identifizieren.

In den folgenden Abschnitten wird beschrieben, wie Sie Mithilfe von Azure AI Text Analytics nach vertraulichen Daten und Azure AI Content Safety suchen, um unangemessene Textinhalte zu identifizieren. Verwenden Sie diese Funktionen, um Ihre Inhalte zu überprüfen, bevor Sie die E-Mail mithilfe von Azure Communication Services senden.

Voraussetzungen

Sie müssen diese Schnellstartanleitungen durchgehen, um die Azure KI-Ressourcen einzurichten:

Prüfen der Voraussetzungen

Führen Sie in einem Terminal- oder Befehlsfenster den Befehl „dotnet“ aus, um sich zu vergewissern, dass die .NET-Clientbibliothek installiert ist.

reg query "HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\NET Framework Setup\NDP"
Zeigen Sie die Unterdomänen an, die Ihrer E-Mail-Communication Services-Ressource zugeordnet sind. Melden Sie sich beim Azure-Portal an. Suchen Sie Ihre E-Mail-Communication Services-Ressource. Öffnen Sie die Registerkarte Domänen bereitstellen im linken Navigationsbereich.

Hinweis

Stellen Sie sicher, dass die E-Mail-Unterdomäne, die Sie zum Senden von E-Mails verwenden möchten, in Ihrer E-Mail-Kommunikationsressource überprüft wird. Weitere Informationen finden Sie im Schnellstart: Hinzufügen von benutzerdefinierten überprüften E-Mail-Domänen.
Zeigen Sie die Domänen an, die mit Ihrer Azure Communication Services-Ressource verbunden sind. Melden Sie sich beim Azure-Portal an. Suchen Sie Ihre Azure Communication Services-Ressource. Öffnen Sie die Registerkarte E-Mail>Domänen im linken Navigationsbereich.

Hinweis

Überprüfte benutzerdefinierte Unterdomänen müssen mit Ihrer Azure Communication Services-Ressource verbunden sein, bevor Sie die Ressource zum Senden von E-Mails verwenden. Weitere Informationen finden Sie im Schnellstart: Verbinden einer überprüften E-Mail-Domäne.

Erstellen einer neuen C#-Anwendung

In diesem Abschnitt wird beschrieben, wie Sie eine neue C#-Anwendung erstellen, erforderliche Pakete installieren und die Main-Funktion erstellen.

Verwenden Sie in einem Konsolenfenster (z. B. cmd, PowerShell oder Bash) den Befehl dotnet new zum Erstellen einer neuen Konsolen-App mit dem Namen EmailPreCheck. Dieser Befehl erstellt ein einfaches „Hallo Welt“-C#-Projekt mit einer einzigen Quelldatei: Program.cs.

dotnet new console -o EmailPreCheck
Wechseln Sie zum neu erstellten EmailPreCheck-App-Ordner, und verwenden Sie den Befehl dotnet build, um Ihre Anwendung zu kompilieren.

cd EmailPreCheck

dotnet build

Installieren erforderlicher Pakete

Installieren Sie im Anwendungsverzeichnis den E-Mail-Client für Azure Communication Services und Azure KI-Bibliotheken für .NET-Pakete mithilfe der dotnet add package-Befehle.

dotnet add package Azure.Communication.Email

dotnet add package Azure.AI.TextAnalytics

dotnet add package Microsoft.Azure.CognitiveServices.ContentModerator

dotnet add package Azure.AI.ContentSafety

Erstellen der Main-Funktion

Öffnen Sie Program.cs und ersetzen Sie den vorhandenen Inhalt durch den folgenden Code. Die using-Direktiven umfassen die Azure.Communication.Email und Azure.AI namespaces. Der Rest des Codes beschreibt die SendMail-Funktion für Ihr Programm.

using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;

using Azure;
using Azure.Communication.Email;
using Azure.AI.TextAnalytics;
using Azure.AI.ContentSafety;
namespace SendEmail
{
  internal class Program
  {
    static async Task Main(string[] args)    {
	// Authenticate and create the Azure Communication Services email client

	// Set sample content
    
    // Pre-check for sensitive data and inappropriate content

	// Send Email
    }
  }
}

Funktion hinzufügen, die auf vertrauliche Daten überprüft

Erstellen Sie eine neue Funktion, um den E-Mail-Betreff und den Textkörper auf vertrauliche Daten wie Sozialversicherungsnummern und Kreditkartennummern zu analysieren.

private static async Task<bool> AnalyzeSensitiveData(List<string> documents)
{
// Client authentication goes here


// Function implementation goes here

}

Erstellen des Textanalyse-Clients mit Authentifizierung

Erstellen Sie eine neue Funktion mit einem Textanalyse-Client, der auch Ihre Verbindungsinformationen abruft. Fügen Sie der AnalyzeSensitiveData-Funktion den folgenden Code hinzu, um den Verbindungsschlüssel und den Endpunkt für die Ressource aus den Umgebungsvariablen namens LANGUAGE_KEY und LANGUAGE_ENDPOINT abzurufen. Außerdem werden die neuen Variablen TextAnalyticsClient und AzureKeyCredential erstellt. Weitere Informationen zum Verwalten Ihrer Textanalyseverbindungsinformationen finden Sie im Schnellstart: Erkennen von personenbezogenen Daten (Personally Identifiable Information, PII) > Abrufen Ihres Schlüssels und Endpunkts.

// This example requires environment variables named "LANGUAGE_KEY" and "LANGUAGE_ENDPOINT"
string languageKey = Environment.GetEnvironmentVariable("LANGUAGE_KEY");
string languageEndpoint = Environment.GetEnvironmentVariable("LANGUAGE_ENDPOINT");
var client = new TextAnalyticsClient(new Uri(languageEndpoint), new AzureKeyCredential(languageKey));

Überprüfen des Inhalts auf vertrauliche Daten

Durchlaufen Sie den Inhalt, um nach vertraulichen Daten zu suchen. Starten Sie die Empfindlichkeitsprüfung mit Baseline von false. Wenn vertrauliche Daten gefunden werden, geben Sie true zurück.

Fügen Sie der AnalyzeSensitiveData-Funktion nach der Zeile, welche die TextAnalyticsClient-Variable erstellt, den folgenden Code hinzu.

bool sensitiveDataDetected = false;  // we start with a baseline that of no sensitive data
var actions = new TextAnalyticsActions
{
    RecognizePiiEntitiesActions = new List<RecognizePiiEntitiesAction> { new RecognizePiiEntitiesAction() }
};

var operation = await client.StartAnalyzeActionsAsync(documents, actions);
await operation.WaitForCompletionAsync();

await foreach (var documentResults in operation.Value)
{
    foreach (var actionResult in documentResults.RecognizePiiEntitiesResults)
    {
        if (actionResult.HasError)
        {
            Console.WriteLine($"Error: {actionResult.Error.ErrorCode} - {actionResult.Error.Message}");
                        
        }
        else
        {
            foreach (var document in actionResult.DocumentsResults)
            {
                foreach (var entity in document.Entities)
                {
                    if (document.Entities.Count > 0)
                    {
                        sensitiveDataDetected = true; // Sensitive data detected
                    }

                }
            }
        }
                 
    }
}
return sensitiveDataDetected;

Funktion hinzufügen, die auf unangemessenen Inhalt überprüft

Erstellen Sie eine weitere neue Funktion, um den E-Mail-Betreff und den Textkörper auf unangemessene Inhalte wie Hass oder Gewalt zu analysieren.

static async Task<bool> AnalyzeInappropriateContent(List<string> documents)
{
// Client authentication goes here

// Function implementation goes here
}

Erstellen des Inhaltssicherheitsclients mit Authentifizierung

Erstellen Sie eine neue Funktion mit einem Content Safety-Client, der auch Ihre Verbindungsinformationen abruft. Fügen Sie der AnalyzeInappropriateContent-Funktion den folgenden Code hinzu, um den Verbindungsschlüssel und den Endpunkt für die Ressource aus den Umgebungsvariablen namens CONTENT_LANGUAGE_KEY und CONTENT_LANGUAGE_ENDPOINT abzurufen. Außerdem wird eine neue ContentSafetyClient-Variable erstellt. Wenn Sie dieselbe Azure KI-Instanz für Textanalyse verwenden, bleiben diese Werte gleich. Weitere Informationen zum Verwalten Ihrer Verbindungsinformationen zur Inhaltssicherheit finden Sie unter Schnellstart: Erstellen der Inhaltssicherheitsressource.

// This example requires environment variables named "CONTENT_LANGUAGE_KEY" and "CONTENT_LANGUAGE_ENDPOINT"
 string contentSafetyLanguageKey = Environment.GetEnvironmentVariable("CONTENT_LANGUAGE_KEY");
string contentSafetyEndpoint = Environment.GetEnvironmentVariable("CONTENT_LANGUAGE_ENDPOINT");
var client = new ContentSafetyClient(new Uri(contentSafetyEndpoint), new AzureKeyCredential(contentSafetyLanguageKey));

Auf unangemessene Inhalte überprüfen

Durchlaufen Sie den Inhalt, um auf unangemessene Inhalte zu überprüfen. Starten Sie die Erkennung von unangemessenem Inhalt mit einer Baseline von false. Wenn unangemessener Inhalt gefunden wird, geben Sie true zurück.

Fügen Sie der AnalyzeInappropriateContent-Funktion nach der Zeile, welche die ContentSafetyClient-Variable erstellt, den folgenden Code hinzu.

bool inappropriateTextDetected = false;
foreach (var document in documents)
{
    var options = new AnalyzeTextOptions(document);
    AnalyzeTextResult response = await client.AnalyzeTextAsync(options);
    // Check the response
    if (response != null)
    {
        // Access the results from the response
        foreach (var category in response.CategoriesAnalysis)
        {
            if (category.Severity > 2) // Severity: 0=safe, 2=low, 4=medium, 6=high
            {
                inappropriateTextDetected = true;
            }
        }
    }
    else
    {
        Console.WriteLine("Failed to analyze content.");
    }
}
return inappropriateTextDetected; // No inappropriate content detected

Aktualisieren der Main-Funktion zum Ausführen von Vorabüberprüfungen und Senden von E-Mails

Nachdem Sie nun die beiden Funktionen zum Überprüfen vertraulicher Daten und unangemessener Inhalte hinzugefügt haben, können Sie sie aufrufen, bevor E-Mails von Azure Communication Services versendet werden.

Erstellen und Authentifizieren des E-Mail-Clients

Sie haben einige Optionen für die Authentifizierung für einen E-Mail-Client. In diesem Beispiel wird die Verbindungszeichenfolge aus einer Umgebungsvariable abgerufen.

Öffnen Sie Program.cs in einem Editor. Fügen Sie den folgenden Code zum Textkörper der Main-Funktion hinzu, um eine EmailClient mit der Verbindungszeichenfolge zu initialisieren. Dieser Code ruft die Verbindungszeichenfolge für die Ressource aus einer Umgebungsvariablen namens COMMUNICATION_SERVICES_CONNECTION_STRING ab. Weitere Informationen zum Verwalten der Ressourcenverbindungszeichenfolge finden Sie im Schnellstart: Erstellen und Verwalten von Communication Services-Ressourcen > Speichern Ihrer Verbindungszeichenfolge.

// This code shows how to fetch your connection string from an environment variable.
string connectionString = Environment.GetEnvironmentVariable("COMMUNICATION_SERVICES_CONNECTION_STRING");
EmailClient emailClient = new EmailClient(connectionString);

Hinzufügen von Beispielinhalten

Fügen Sie nach den Zeilen, die den E-Mail-Client erstellen, den Beispielinhalt der E-Mail in die Main-Funktion ein.

Sie müssen die E-Mail-Adresse des Absenders abrufen. Weitere Informationen zu Azure Communication Services-E-Mail-Domänen finden Sie im Schnellstart: Hinzufügen von Azure Managed Domains zum E-Mail-Communication Service.

Ändern Sie die Variable für die E-Mail-Adresse des Empfängers.

Setzen Sie sowohl den Betreff als auch den Nachrichtentext in eine List<string>, die von den beiden Inhaltsüberprüfungsfunktionen verwendet werden kann.

//Set sample content
var sender = "donotreply@xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.azurecomm.net"; // get the send email from your email resource in the Azure Portal
var recipient = "emailalias@contoso.com"; // modify the recipient
var subject = "Precheck Azure Communication Service Email with Azure AI";
var htmlContent = "<html><body><h1>Precheck email test</h1><br/><h4>This email message is sent from Azure Communication Service Email. </h4>";
htmlContent += "<p> My SSN is 123-12-1234.  My Credit Card Number is: 1234 4321 5678 8765.  My address is 1011 Main St, Redmond, WA, 998052 </p>";
htmlContent += "<p>A 51-year-old man was found dead in his car. There were blood stains on the dashboard and windscreen.";
htmlContent += "At autopsy, a deep, oblique, long incised injury was found on the front of the neck. It turns out that he died by suicide.</p>";
htmlContent += "</body></html>";
List<string> documents = new List<string> { subject, htmlContent };

Vorabüberprüfung von Inhalten vor dem Senden von E-Mails

Sie müssen die beiden Funktionen aufrufen, um nach Verstößen zu suchen, und die Ergebnisse verwenden, um festzustellen, ob die E-Mail gesendet werden soll. Fügen Sie der Main-Funktion nach dem Beispielinhalt den folgenden Code hinzu.

// Pre-Check content
bool containsSensitiveData = await AnalyzeSensitiveData(documents);
bool containsInappropriateContent = await AnalyzeInappropriateContent(documents);

// Send email only if not sensitive data or inappropriate content is detected
if (containsSensitiveData == false && containsInappropriateContent == false)
{

    /// Send the email message with WaitUntil.Started
    EmailSendOperation emailSendOperation = await emailClient.SendAsync(
        Azure.WaitUntil.Started,
        sender,
        recipient,
        subject,
        htmlContent);

    /// Call UpdateStatus on the email send operation to poll for the status manually
    try
    {
        while (true)
        {
            await emailSendOperation.UpdateStatusAsync();
            if (emailSendOperation.HasCompleted)
            {
                break;
            }
            await Task.Delay(100);
        }

        if (emailSendOperation.HasValue)
        {
            Console.WriteLine($"Email queued for delivery. Status = {emailSendOperation.Value.Status}");
        }
    }
    catch (RequestFailedException ex)
    {
        Console.WriteLine($"Email send failed with Code = {ex.ErrorCode} and Message = {ex.Message}");
    }

    /// Get the OperationId so that it can be used for tracking the message for troubleshooting
    string operationId = emailSendOperation.Id;
    Console.WriteLine($"Email operation id = {operationId}");
}
else
{
    Console.WriteLine("Sensitive data and/or inappropriate content detected, email not sent\n\n");
}

Nächste Schritte

Weitere Informationen zu Azure Communication Services.
Erfahren Sie mehr über Azure AI Foundry.