Entwickeln von Azure KI Services-Anwendungen mit Azure Key Vault

• Ein gültiges Azure-Abonnement: Erstellen Sie ein kostenloses Abonnement.
• Visual Studio-IDE
• Ein Azure Key Vault
• Eine Azure KI Services-Ressource

• Ein gültiges Azure-Abonnement: Erstellen Sie ein kostenloses Abonnement.
• Python 3.7 oder höher
• Azure CLI oder Azure PowerShell
• Ein Azure Key Vault
• Eine Azure KI Services-Ressource

• Ein gültiges Azure-Abonnement: Erstellen Sie ein kostenloses Abonnement.
• Java Development Kit (JDK), Version 8 oder höher
• Azure CLI oder Azure PowerShell
• Ein Azure Key Vault
• Eine Azure KI Services-Ressource

• Ein gültiges Azure-Abonnement: Erstellen Sie ein kostenloses Abonnement.
• Aktuelle Version von Node.js v14 LTS oder höher
• Azure CLI oder Azure PowerShell
• Ein Azure Key Vault
• Eine Azure KI Services-Ressource

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.

az login

Connect-AzAccount

Gewähren des Zugriffs auf Ihren Schlüsseltresor

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

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

Set-AzKeyVaultAccessPolicy -VaultName 'Your-Key-Vault-Name' -UserPrincipalName 'user@domain.com' -PermissionsToSecrets delete,get,list,set,purge -PassThru

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.

az login

Connect-AzAccount

Gewähren des Zugriffs auf Ihren Schlüsseltresor

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

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

Set-AzKeyVaultAccessPolicy -VaultName 'Your-Key-Vault-Name' -UserPrincipalName 'user@domain.com' -PermissionsToSecrets delete,get,list,set,purge -PassThru

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.

az login

Connect-AzAccount

Gewähren des Zugriffs auf Ihren Schlüsseltresor

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

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

Set-AzKeyVaultAccessPolicy -VaultName 'Your-Key-Vault-Name' -UserPrincipalName 'user@domain.com' -PermissionsToSecrets delete,get,list,set,purge -PassThru

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.

az login

Connect-AzAccount

Gewähren des Zugriffs auf Ihren Schlüsseltresor

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

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

Set-AzKeyVaultAccessPolicy -VaultName 'Your-Key-Vault-Name' -UserPrincipalName 'user@domain.com' -PermissionsToSecrets delete,get,list,set,purge -PassThru

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.