Entwickeln von Azure KI Services-Anwendungen mit Key Vault

  • Artikel

Hier erfahren Sie, wie Sie Azure KI Services-Anwendungen sicher entwickeln, indem Sie Azure Key Vault verwenden.

Key Vault reduziert die Gefahr, dass Geheimnisse versehentlich preisgegeben werden, da in Ihrer Anwendung keine Sicherheitsinformationen gespeichert werden.

Voraussetzungen

Hinweis

Lesen Sie die Dokumentation und Schnellstartartikel für den verwendeten Azure KI Services, um ein Verständnis der folgenden Dinge zu erhalten:

  • Die Anmeldeinformationen und andere Informationen, die Sie zum Senden von API-Aufrufen benötigen.
  • Die Pakete und der Code, die Sie zum Ausführen Ihrer Anwendung benötigen.

Abrufen Ihrer Anmeldeinformationen aus Ihrer Azure KI Services-Ressource

Bevor Sie Ihrem Azure-Schlüsseltresor Ihre Anmeldeinformationen hinzufügen, müssen Sie sie aus Ihrer Azure KI Services-Ressource abrufen. Wenn Ihr Dienst beispielsweise einen Schlüssel und Endpunkt benötigt, finden Sie diese mithilfe der folgenden Schritte:

  1. Navigieren Sie im Azure-Portal zu Ihrer Ressource.

  2. Wählen Sie im reduzierbaren Menü auf der linken Seite Schlüssel und Endpunkt aus.

    A screenshot showing the key and endpoint page in the Azure portal.

Einige Azure KI Services-Instanzen erfordern unterschiedliche Informationen zur Authentifizierung von API-Aufrufen, wie etwa einen Schlüssel und eine Region. Achten Sie darauf, diese Informationen abzurufen, bevor Sie fortfahren.

Hinzufügen Ihrer Anmeldeinformationen zu Ihrem Schlüsseltresor

Damit Ihre Anwendung Ihre Anmeldeinformationen abrufen und zum Authentifizieren von API-Aufrufen verwenden kann, müssen Sie sie ihren Schlüsseltresorgeheimnissen hinzufügen.

Wiederholen Sie diese Schritte, um für jede erforderliche Ressourcenanmeldeinformation ein Geheimnis zu generieren. Beispielsweise für einen Schlüssel und Endpunkt. Diese Geheimnisnamen werden später verwendet, um Ihre Anwendung zu authentifizieren.

  1. Öffnen Sie eine neue Browserregisterkarte oder ein neues Fenster. Navigieren Sie im Azure-Portal zu Ihrem Schlüsseltresor.

  2. Wählen Sie im reduzierbaren Menü auf der linken Seite Objekte>Geheimnisse aus.

  3. Wählen Sie die Option Generieren/Importieren aus.

    A screenshot showing the key vault key page in the Azure portal.

  4. Geben Sie auf dem Bildschirm Geheimnis erstellen die folgenden Werte ein:

    Name Wert
    Uploadoptionen Manuell
    Name Ein Geheimnisname für Ihren Schlüssel oder Endpunkt. Beispielsweise „CognitiveServicesKey“ oder „CognitiveServicesEndpoint“
    Wert Ihr Azure KI Services-Ressourcenschlüssel oder -Endpunkt.

    Später verwendet Ihre Anwendung den „Namen“ des Geheimnisses, um sicher auf den „Wert“ zuzugreifen.

  5. Behalten Sie bei den anderen Optionen die Standardwerte bei. Klicken Sie auf Erstellen.

    Tipp

    Achten Sie darauf, sich die Namen zu merken, die Sie für Ihre Geheimnisse festlegen, da Sie sie später in Ihrer Anwendung verwenden.

Sie sollten jetzt über benannte Geheimnisse für Ihre Ressourceninformationen verfügen.

Erstellen einer Umgebungsvariable für den Namen Ihres Schlüsseltresors

Es empfiehlt sich, für den Namen Ihres Azure-Schlüsseltresors eine Umgebungsvariable zu erstellen. Ihre Anwendung liest diese Umgebungsvariable zur Laufzeit, um Ihre Schlüssel- und Endpunktinformationen abzurufen.

Verwenden Sie zum Festlegen von Umgebungsvariablen einen der folgenden Befehle. KEY_VAULT_NAME mit dem Namen der Umgebungsvariable, und ersetzen Sie Your-Key-Vault-Name durch den Namen Ihres Schlüsseltresors, der in der Umgebungsvariable gespeichert werden soll.

Erstellen Sie eine persistente Umgebungsvariable, und weisen Sie sie dem entsprechenden Wert zu.

setx KEY_VAULT_NAME "Your-Key-Vault-Name"

Lesen Sie die Umgebungsvariable in einer neuen Instanz der Eingabeaufforderung.

echo %KEY_VAULT_NAME%

Authentifizieren bei Azure mithilfe von Visual Studio

Entwickler, die Visual Studio 2017 oder höher verwenden, können ein Microsoft Entra-Konto mithilfe von Visual Studio authentifizieren. Dadurch können Sie auf Geheimnisse in Ihrem Schlüsseltresor zugreifen, indem Sie sich innerhalb der IDE bei Ihrem Azure-Abonnement anmelden.

Wählen Sie zur Authentifizierung in Visual Studio im oberen Navigationsmenü Extras und dann Optionen aus. Navigieren Sie zur Option Azure-Dienstauthentifizierung, um sich mit Ihrem Benutzernamen und Kennwort anzumelden.

Authentifizieren mithilfe der Befehlszeile

Damit Sie Zugriff auf Ihren Schlüsseltresor erteilen können, müssen Sie sich mit Ihrem Microsoft Entra-Benutzernamen und -Kennwort authentifizieren.

Zum Authentifizieren bei der Azure CLI führen Sie den Befehl az login aus.

az login

Auf Systemen mit einem Standardwebbrowser startet die Azure CLI den Browser für die Authentifizierung. Für Systeme ohne Standardwebbrowser verwendet der az login-Befehl den Gerätecode-Authentifizierungsfluss. Durch Angeben des Arguments --use-device-code können Sie ferner erzwingen, dass die Azure CLI den Gerätecodeflow verwendet, anstatt einen Browser zu starten.

Wenn Sie mehrere Abonnements haben, stellen Sie sicher, dass Sie das Azure-Abonnement auswählen, das Ihren Schlüsseltresor enthält.

Gewähren des Zugriffs auf Ihren Schlüsseltresor

Erstellen Sie eine Zugriffsrichtlinie für Ihren Schlüsseltresor, die Ihrem Benutzerkonto Geheimnisberechtigungen erteilt.

Zum Festlegen der Zugriffsrichtlinie führen Sie den Befehl az keyvault set-policy aus. Ersetzen Sie Your-Key-Vault-Name durch den Namen Ihres Schlüsseltresors. Ersetzen Sie user@domain.com mit Ihrem Microsoft Entra-Benutzernamen.

az keyvault set-policy --name Your-Key-Vault-Name --upn user@domain.com --secret-permissions delete get list set purge

Erstellen einer neuen C#-Anwendung

Erstellen Sie über die Visual Studio-IDE eine neue .NET Core-Konsolenanwendung. Dadurch wird ein Projekt vom Typ „Hallo Welt“ mit einer einzelnen C#-Quelldatei (program.cs) erstellt.

Installieren Sie die folgenden Clientbibliotheken, indem Sie im Projektmappen-Explorer mit der rechten Maustaste auf die Projektmappe klicken und NuGet-Pakete verwalten auswählen. Wählen Sie im Paket-Manager, der geöffnet wird, die Option Durchsuchen aus, suchen Sie nach den folgenden Bibliotheken, und wählen Sie für jede Installieren aus:

  • Azure.Security.KeyVault.Secrets
  • Azure.Identity

Importieren des Beispielcodes

Kopieren Sie den folgenden Beispielcode in Ihre program.cs-Datei. Ersetzen Sie Your-Key-Secret-Name und Your-Endpoint-Secret-Name durch die Geheimnisnamen, die Sie im Schlüsseltresor festgelegt haben.

using System;
using System.Threading.Tasks;
using Azure;
using Azure.Identity;
using Azure.Security.KeyVault.Secrets;
using System.Net;

namespace key_vault_console_app
{
    class Program
    {
        static async Task Main(string[] args)
        {
            //Name of your key vault
            var keyVaultName = Environment.GetEnvironmentVariable("KEY_VAULT_NAME");

            //variables for retrieving the key and endpoint from your key vault.
            //Set these variables to the names you created for your secrets
            const string keySecretName = "Your-Key-Secret-Name";
            const string endpointSecretName = "Your-Endpoint-Secret-Name";

            //Endpoint for accessing your key vault
            var kvUri = $"https://{keyVaultName}.vault.azure.net";

            var keyVaultClient = new SecretClient(new Uri(kvUri), new DefaultAzureCredential());

            Console.WriteLine($"Retrieving your secrets from {keyVaultName}.");

            //Key and endpoint secrets retrieved from your key vault
            var keySecret = await keyVaultClient.GetSecretAsync(keySecretName);
            var endpointSecret = await keyVaultClient.GetSecretAsync(endpointSecretName);
            Console.WriteLine($"Your key secret value is: {keySecret.Value.Value}");
            Console.WriteLine($"Your endpoint secret value is: {endpointSecret.Value.Value}");
            Console.WriteLine("Secrets retrieved successfully");

        }
    }
}

Ausführen der Anwendung

Führen Sie die Anwendung aus, indem Sie oben in Visual Studio die Schaltfläche Debuggen auswählen. Ihre Schlüssel- und Endpunktgeheimnisse werden aus Ihrem Schlüsseltresor abgerufen.

Senden eines Testaufrufs an den Sprachdienst (optional)

Wenn Sie eine Ressource für mehrere Dienste oder eine Sprachressource verwenden, können Sie Ihre Anwendung aktualisieren, indem Sie die folgenden Schritte ausführen, um einen Beispielaufruf zur Erkennung benannter Entitäten zu senden, indem Sie einen Schlüssel und Endpunkt aus Ihrem Schlüsseltresor abrufen.

  1. Installieren Sie die Azure.AI.TextAnalytics-Bibliothek, indem Sie mit der rechten Maustaste im Projektmappen-Explorer auf die Projektmappe klicken und NuGet-Pakete verwalten auswählen. Wählen Sie im Paket-Manager, der geöffnet wird, die Option Durchsuchen aus, suchen Sie nach den folgenden Bibliotheken, und wählen Sie für jede Installieren aus:

  2. Fügen Sie am Anfang Ihrer program.cs-Datei die folgende Anweisung hinzu.

    using Azure.AI.TextAnalytics;

  3. Fügen Sie Ihrer Anwendung das folgende Codebeispiel hinzu.

    // Example method for extracting named entities from text 
private static void EntityRecognitionExample(string keySecret, string endpointSecret)
{
    //String to be sent for Named Entity Recognition
    var exampleString = "I had a wonderful trip to Seattle last week.";

    AzureKeyCredential azureKeyCredential = new AzureKeyCredential(keySecret);
    Uri endpoint = new Uri(endpointSecret);
    var languageServiceClient = new TextAnalyticsClient(endpoint, azureKeyCredential);

    Console.WriteLine($"Sending a Named Entity Recognition (NER) request");
    var response = languageServiceClient.RecognizeEntities(exampleString);
    Console.WriteLine("Named Entities:");
    foreach (var entity in response.Value)
    {
        Console.WriteLine($"\tText: {entity.Text},\tCategory: {entity.Category},\tSub-Category: {entity.SubCategory}");
        Console.WriteLine($"\t\tScore: {entity.ConfidenceScore:F2},\tLength: {entity.Length},\tOffset: {entity.Offset}\n");
    }
}

  4. Fügen Sie den folgenden Code hinzu, um EntityRecognitionExample() aus Ihrer main-Methode aufzurufen, mit Ihren Schlüssel- und Endpunktwerten.

    EntityRecognitionExample(keySecret.Value.Value, endpointSecret.Value.Value);

  5. Führen Sie die Anwendung aus.

Authentifizieren Ihrer Anwendung

Damit Sie Zugriff auf Ihren Schlüsseltresor erteilen können, müssen Sie sich mit Ihrem Microsoft Entra-Benutzernamen und -Kennwort authentifizieren.

Zum Authentifizieren bei der Azure CLI führen Sie den Befehl az login aus.

az login

Auf Systemen mit einem Standardwebbrowser startet die Azure CLI den Browser für die Authentifizierung. Für Systeme ohne Standardwebbrowser verwendet der az login-Befehl den Gerätecode-Authentifizierungsfluss. Durch Angeben des Arguments --use-device-code können Sie ferner erzwingen, dass die Azure CLI den Gerätecodeflow verwendet, anstatt einen Browser zu starten.

Wenn Sie mehrere Abonnements haben, stellen Sie sicher, dass Sie das Azure-Abonnement auswählen, das Ihren Schlüsseltresor enthält.

Gewähren des Zugriffs auf Ihren Schlüsseltresor

Erstellen Sie eine Zugriffsrichtlinie für Ihren Schlüsseltresor, die Ihrem Benutzerkonto Geheimnisberechtigungen erteilt.

Zum Festlegen der Zugriffsrichtlinie führen Sie den Befehl az keyvault set-policy aus. Ersetzen Sie Your-Key-Vault-Name durch den Namen Ihres Schlüsseltresors. Ersetzen Sie user@domain.com mit Ihrem Microsoft Entra-Benutzernamen.

az keyvault set-policy --name Your-Key-Vault-Name --upn user@domain.com --secret-permissions delete get list set purge

Erstellen einer Python-Anwendung

Erstellen Sie einen neuen Ordner namens keyVaultExample. Verwenden Sie dann Ihren bevorzugten Code-Editor, um eine Datei namens program.py innerhalb des neu erstellten Ordners zu erstellen.

Installieren von Key Vault und Sprachdienstpaketen

  1. Navigieren Sie in einem Terminal oder an einer Eingabeaufforderung zu Ihrem Projektordner, und installieren Sie die Microsoft Entra-Identitätsbibliothek:

    pip install azure-identity

  2. Installieren Sie die Key Vault-Geheimnisbibliothek:

    pip install azure-keyvault-secrets

Importieren des Beispielcodes

Fügen Sie der Datei program.py das folgende Codebeispiel hinzu. Ersetzen Sie Your-Key-Secret-Name und Your-Endpoint-Secret-Name durch die Geheimnisnamen, die Sie im Schlüsseltresor festgelegt haben.

import os
from azure.keyvault.secrets import SecretClient
from azure.identity import DefaultAzureCredential
from azure.core.credentials import AzureKeyCredential

keyVaultName = os.environ["KEY_VAULT_NAME"]

# Set these variables to the names you created for your secrets
keySecretName = "Your-Key-Secret-Name"
endpointSecretName = "Your-Endpoint-Secret-Name"

# URI for accessing key vault
KVUri = f"https://{keyVaultName}.vault.azure.net"

# Instantiate the client and retrieve secrets
credential = DefaultAzureCredential()
kv_client = SecretClient(vault_url=KVUri, credential=credential)

print(f"Retrieving your secrets from {keyVaultName}.")

retrieved_key = kv_client.get_secret(keySecretName).value
retrieved_endpoint = kv_client.get_secret(endpointSecretName).value

print(f"Your secret key value is {retrieved_key}.");
print(f"Your secret endpoint value is {retrieved_endpoint}.");

Ausführen der Anwendung

Verwenden Sie den folgenden Befehl, um die Anwendung auszuführen. Ihre Schlüssel- und Endpunktgeheimnisse werden aus Ihrem Schlüsseltresor abgerufen.

python ./program.py

Senden eines Testaufrufs an den Sprachdienst (optional)

Wenn Sie eine Ressource für mehrere Dienste oder eine Sprachressource verwenden, können Sie Ihre Anwendung aktualisieren, indem Sie die folgenden Schritte ausführen, um einen Beispielaufruf zur Erkennung benannter Entitäten zu senden, indem Sie einen Schlüssel und Endpunkt aus Ihrem Schlüsseltresor abrufen.

  1. Installieren der Sprachdienstbibliothek:

    pip install azure-ai-textanalytics==5.1.0

  2. Fügen Sie Ihrer Anwendung den folgenden Code hinzu

    from azure.ai.textanalytics import TextAnalyticsClient
# Authenticate the key vault secrets client using your key and endpoint 
azure_key_credential = AzureKeyCredential(retrieved_key)
# Now you can use key vault credentials with the Language service
language_service_client = TextAnalyticsClient(
    endpoint=retrieved_endpoint, 
    credential=azure_key_credential)

# Example of recognizing entities from text

print("Sending NER request")

try:
    documents = ["I had a wonderful trip to Seattle last week."]
    result = language_service_client.recognize_entities(documents = documents)[0]
    print("Named Entities:\n")
    for entity in result.entities:
        print("\tText: \t", entity.text, "\tCategory: \t", entity.category, "\tSubCategory: \t", entity.subcategory,
                "\n\tConfidence Score: \t", round(entity.confidence_score, 2), "\tLength: \t", entity.length, "\tOffset: \t", entity.offset, "\n")

except Exception as err:
    print("Encountered exception. {}".format(err))

  3. Führen Sie die Anwendung aus.

Authentifizieren Ihrer Anwendung

Damit Sie Zugriff auf Ihren Schlüsseltresor erteilen können, müssen Sie sich mit Ihrem Microsoft Entra-Benutzernamen und -Kennwort authentifizieren.

Zum Authentifizieren bei der Azure CLI führen Sie den Befehl az login aus.

az login

Auf Systemen mit einem Standardwebbrowser startet die Azure CLI den Browser für die Authentifizierung. Für Systeme ohne Standardwebbrowser verwendet der az login-Befehl den Gerätecode-Authentifizierungsfluss. Durch Angeben des Arguments --use-device-code können Sie ferner erzwingen, dass die Azure CLI den Gerätecodeflow verwendet, anstatt einen Browser zu starten.

Wenn Sie mehrere Abonnements haben, stellen Sie sicher, dass Sie das Azure-Abonnement auswählen, das Ihren Schlüsseltresor enthält.

Gewähren des Zugriffs auf Ihren Schlüsseltresor

Erstellen Sie eine Zugriffsrichtlinie für Ihren Schlüsseltresor, die Ihrem Benutzerkonto Geheimnisberechtigungen erteilt.

Zum Festlegen der Zugriffsrichtlinie führen Sie den Befehl az keyvault set-policy aus. Ersetzen Sie Your-Key-Vault-Name durch den Namen Ihres Schlüsseltresors. Ersetzen Sie user@domain.com mit Ihrem Microsoft Entra-Benutzernamen.

az keyvault set-policy --name Your-Key-Vault-Name --upn user@domain.com --secret-permissions delete get list set purge

Erstellen einer Java-Anwendung

Erstellen Sie in Ihrer bevorzugten IDE ein neues Java-Konsolenanwendungsprojekt, und erstellen Sie eine Klasse namens Example.

Hinzufügen von Abhängigkeiten

Fügen Sie in Ihrem Projekt Ihrer pom.xml-Datei die folgenden Abhängigkeiten hinzu.

<dependencies>

        <dependency>
            <groupId>com.azure</groupId>
            <artifactId>azure-security-keyvault-secrets</artifactId>
            <version>4.2.3</version>
        </dependency>
        <dependency>
            <groupId>com.azure</groupId>
            <artifactId>azure-identity</artifactId>
            <version>1.2.0</version>
        </dependency>
    </dependencies>

Importieren des Beispielcodes

Kopieren Sie den folgenden Code in eine Datei namens Example.java. Ersetzen Sie Your-Key-Secret-Name und Your-Endpoint-Secret-Name durch die Geheimnisnamen, die Sie im Schlüsseltresor festgelegt haben.

import com.azure.identity.DefaultAzureCredentialBuilder;
import com.azure.security.keyvault.secrets.SecretClient;
import com.azure.security.keyvault.secrets.SecretClientBuilder;
import com.azure.core.credential.AzureKeyCredential;

public class Example {

    public static void main(String[] args) {

        String keyVaultName = System.getenv("KEY_VAULT_NAME");
        String keyVaultUri = "https://" + keyVaultName + ".vault.azure.net";

        //variables for retrieving the key and endpoint from your key vault.
        //Set these variables to the names you created for your secrets
        String keySecretName = "Your-Key-Secret-Name";
        String endpointSecretName = "Your-Endpoint-Secret-Name";

        //Create key vault secrets client
        SecretClient secretClient = new SecretClientBuilder()
                .vaultUrl(keyVaultUri)
                .credential(new DefaultAzureCredentialBuilder().build())
                .buildClient();

        //retrieve key and endpoint from key vault
        String keyValue = secretClient.getSecret(keySecretName).getValue();
        String endpointValue = secretClient.getSecret(endpointSecretName).getValue();
        System.out.printf("Your secret key value is: %s", keyValue)
        System.out.printf("Your secret endpoint value is: %s", endpointValue)
    }
}

Senden eines Testaufrufs an den Sprachdienst (optional)

Wenn Sie eine Ressource für mehrere Dienste oder eine Sprachressource verwenden, können Sie Ihre Anwendung aktualisieren, indem Sie die folgenden Schritte ausführen, um einen Beispielaufruf zur Erkennung benannter Entitäten zu senden, indem Sie einen Schlüssel und Endpunkt aus Ihrem Schlüsseltresor abrufen.

  1. Fügen Sie in Ihrer Anwendung die folgende Abhängigkeit hinzu:

    <dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-ai-textanalytics</artifactId>
    <version>5.1.12</version>
</dependency>

  2. Fügen Sie der Datei die folgenden Importanweisungen hinzu.

    import com.azure.ai.textanalytics.models.*;
import com.azure.ai.textanalytics.TextAnalyticsClientBuilder;
import com.azure.ai.textanalytics.TextAnalyticsClient;

  3. Fügen Sie der Methode main() in Ihrer Anwendung den folgenden Code hinzu:

    
TextAnalyticsClient languageClient = new TextAnalyticsClientBuilder()
        .credential(new AzureKeyCredential(keyValue))
        .endpoint(endpointValue)
        .buildClient();

// Example for recognizing entities in text
String text = "I had a wonderful trip to Seattle last week.";

for (CategorizedEntity entity : languageClient.recognizeEntities(text)) {
    System.out.printf(
            "Recognized entity: %s, entity category: %s, entity sub-category: %s, score: %s, offset: %s, length: %s.%n",
            entity.getText(),
            entity.getCategory(),
            entity.getSubcategory(),
            entity.getConfidenceScore(),
            entity.getOffset(),
            entity.getLength());
}

  4. Ausführen der Anwendung

Authentifizieren Ihrer Anwendung

Damit Sie Zugriff auf Ihren Schlüsseltresor erteilen können, müssen Sie sich mit Ihrem Microsoft Entra-Benutzernamen und -Kennwort authentifizieren.

Zum Authentifizieren bei der Azure CLI führen Sie den Befehl az login aus.

az login

Auf Systemen mit einem Standardwebbrowser startet die Azure CLI den Browser für die Authentifizierung. Für Systeme ohne Standardwebbrowser verwendet der az login-Befehl den Gerätecode-Authentifizierungsfluss. Durch Angeben des Arguments --use-device-code können Sie ferner erzwingen, dass die Azure CLI den Gerätecodeflow verwendet, anstatt einen Browser zu starten.

Wenn Sie mehrere Abonnements haben, stellen Sie sicher, dass Sie das Azure-Abonnement auswählen, das Ihren Schlüsseltresor enthält.

Gewähren des Zugriffs auf Ihren Schlüsseltresor

Erstellen Sie eine Zugriffsrichtlinie für Ihren Schlüsseltresor, die Ihrem Benutzerkonto Geheimnisberechtigungen erteilt.

Zum Festlegen der Zugriffsrichtlinie führen Sie den Befehl az keyvault set-policy aus. Ersetzen Sie Your-Key-Vault-Name durch den Namen Ihres Schlüsseltresors. Ersetzen Sie user@domain.com mit Ihrem Microsoft Entra-Benutzernamen.

az keyvault set-policy --name Your-Key-Vault-Name --upn user@domain.com --secret-permissions delete get list set purge

Erstellen einer neuen Node.js-Anwendung

Erstellen Sie eine Node.js-Anwendung, die Ihren Schlüsseltresor verwendet.

Erstellen Sie in einem Terminal einen Ordner namens key-vault-js-example und wechseln Sie in diesen Ordner:

mkdir key-vault-js-example && cd key-vault-js-example

Initialisieren Sie das Node.js-Projekt:

npm init -y

Installieren von Key Vault und Sprachdienstpaketen

  1. Installieren Sie über das Terminal die Azure Key Vault geheime Bibliothek, @azure/keyvault-secrets für Node.js.

    npm install @azure/keyvault-secrets

  2. Installieren Sie die Azure-Identitätsbibliothek, @azure/identity Paket, um sich bei einem Key Vault zu authentifizieren.

    npm install @azure/identity

Importieren des Codebeispiels

Fügen Sie einer Datei mit dem Namen index.js das folgende Codebeispiel hinzu. Ersetzen Sie Your-Key-Secret-Name und Your-Endpoint-Secret-Name durch die Geheimnisnamen, die Sie im Schlüsseltresor festgelegt haben.

const { SecretClient } = require("@azure/keyvault-secrets");
const { DefaultAzureCredential } = require("@azure/identity");
// Load the .env file if it exists
const dotenv = require("dotenv");
dotenv.config();

async function main() {
    const credential = new DefaultAzureCredential();

    const keyVaultName = process.env["KEY_VAULT_NAME"];
    const url = "https://" + keyVaultName + ".vault.azure.net";

    const kvClient = new SecretClient(url, credential);

    // Set these variables to the names you created for your secrets
    const keySecretName = "Your-Key-Secret-Name";
    const endpointSecretName = "Your-Endpoint-Secret-Name";

    console.log("Retrieving secrets from ", keyVaultName);
    const retrievedKey = await (await kvClient.getSecret(keySecretName)).value;
    const retrievedEndpoint = await (await kvClient.getSecret(endpointSecretName)).value;
    console.log("Your secret key value is: ", retrievedKey);
    console.log("Your secret endpoint value is: ", retrievedEndpoint);
}

main().catch((error) => {
  console.error("An error occurred:", error);
  process.exit(1);
});

Ausführen der Beispielanwendung

Verwenden Sie den folgenden Befehl, um die Anwendung auszuführen. Ihre Schlüssel- und Endpunktgeheimnisse werden aus Ihrem Schlüsseltresor abgerufen.

node index.js

Senden eines Testaufrufs an den Sprachdienst (optional)

Wenn Sie eine Ressource für mehrere Dienste oder eine Sprachressource verwenden, können Sie Ihre Anwendung aktualisieren, indem Sie die folgenden Schritte ausführen, um einen Beispielaufruf zur Erkennung benannter Entitäten zu senden, indem Sie einen Schlüssel und Endpunkt aus Ihrem Schlüsseltresor abrufen.

  1. Installieren Sie die Azure KI Services für Language-Bibliothek, @azure/ai-text-analytics, um API-Anforderungen an den Sprachdienst zu senden.

    npm install @azure/ai-text-analytics@5.1.0

  2. Fügen Sie Ihrer Anwendung den folgenden Code hinzu:

    const { TextAnalyticsClient, AzureKeyCredential } = require("@azure/ai-text-analytics");
// Authenticate the language client with your key and endpoint
const languageClient = new TextAnalyticsClient(retrievedEndpoint,  new AzureKeyCredential(retrievedKey));

// Example for recognizing entities in text
console.log("Sending NER request")
const entityInputs = [
    "I had a wonderful trip to Seattle last week."
];
const entityResults = await languageClient.recognizeEntities(entityInputs);
entityResults.forEach(document => {
    console.log(`Document ID: ${document.id}`);
    document.entities.forEach(entity => {
        console.log(`\tName: ${entity.text} \tCategory: ${entity.category} \tSubcategory: ${entity.subCategory ? entity.subCategory : "N/A"}`);
        console.log(`\tScore: ${entity.confidenceScore}`);
    });
});

  3. Führen Sie die Anwendung aus.

Nächste Schritte