Verwenden von Azure OpenAI ohne Schlüssel

Artikel
11/14/2024

Anwendungsanforderungen an die meisten Azure-Dienste müssen mit Schlüsseln oder kennwortlosen Verbindungen authentifiziert werden. Entwickler müssen darauf achten, dass die Schlüssel nicht an einem unsicheren Ort offengelegt werden. Jeder Benutzer, der Zugriff auf den Schlüssel erhält, kann sich beim Dienst authentifizieren. Die schlüssellose Authentifizierung bietet verbesserte Verwaltungs- und Sicherheitsvorteile gegenüber dem Kontoschlüssel, da kein Schlüssel (und keine Verbindungszeichenfolge) zum Speichern vorhanden ist.

Schlüssellose Verbindungen werden mit den folgenden Schritten aktiviert:

Konfigurieren Sie die Authentifizierung.
Legen Sie je nach Bedarf die Umgebungsvariablen fest.
Verwenden Sie einen Anmeldeinformationstyp für die Azure Identity-Bibliothek, um ein Azure OpenAI-Clientobjekt zu erstellen.

Authentifizierung

Für die Verwendung der Azure-Clientbibliotheken ist die Authentifizierung an Microsoft Entra-ID erforderlich.

Die Authentifizierung unterscheidet sich je nach Umgebung, in der die App ausgeführt wird:

Lokale Entwicklung
Azure

Azure OpenAI Keyless Building Block

Verwenden Sie den folgenden Link, um die Ki-Vorlage für Azure OpenAI Keyless Building Block AI zu erkunden. Diese Vorlage stellt ein Azure OpenAI-Konto mit ihrer RBAC-Rollenberechtigung für die Schlüssellose (Microsoft Entra)-Authentifizierung für den Zugriff auf die OpenAI-API-SDKs bereit.

Hinweis

In diesem Artikel wird mindestens eine KI-App-Vorlage als Grundlage für die Beispiele und Anleitungen im Artikel verwendet. KI-App-Vorlagen bieten Ihnen gut gepflegte, einfach bereitzustellende Referenzimplementierungen, die helfen, einen qualitativ hochwertigen Ausgangspunkt für Ihre KI-Apps zu gewährleisten.

Erkunden Sie die .NET End to End Azure OpenAI Keyless Authentication Building Block AI-Vorlage.

Authentifizierung für die lokale Entwicklung

Wählen Sie ein Tool für Authentifizierung während der lokalen Entwicklung aus.

Authentifizieren für von Azure gehostete Umgebungen

Erfahren Sie, wie Sie die DefaultAzureCredential für Anwendungen verwalten, die in Azure bereitgestellt werden.

Konfigurieren von Rollen für die Autorisierung

Suchen Sie die Rolle für Ihre Verwendung von Azure OpenAI. Je nachdem, wie Sie diese Rolle festlegen möchten, benötigen Sie entweder den Namen oder die ID.

Rollenname Rollen-ID

Für die Azure CLI oder Azure PowerShell können Sie den Rollennamen verwenden. Für Bicep benötigen Sie die Rollen-ID.

Rollenname	Rollen-ID
Für die Azure CLI oder Azure PowerShell können Sie den Rollennamen verwenden.	Für Bicep benötigen Sie die Rollen-ID.

Verwenden Sie die folgende Tabelle, um eine Rolle und eine ID auszuwählen.

Anwendungsfall	Rollenname	Rollen-ID
Assistenten	`Cognitive Services OpenAI Contributor`	`a001fd3d-188f-4b5d-821b-7da978bf7442`
Chatvervollständigungen	`Cognitive Services OpenAI User`	`5e0bd9bd-7b93-4f28-af87-19fc36ad61bd`

Wählen Sie den zu verwendenden Identitätstyp.
- Persönliche Identität: Dies ist Ihre persönliche Identität, die an Ihre Anmeldung bei Azure gebunden ist.
- Verwaltete Identität: Dies ist eine Identität, die von Azure verwaltet und für die Verwendung erstellt wird. Für die verwaltete Identität erstellen Sie eine Benutzerseitig zugewiesene verwaltete Identität. Wenn Sie die verwaltete Identität erstellen, benötigen Sie die Client ID, auch bekannt als die app ID.
Verwenden Sie einen der folgenden Befehle, um Ihre persönliche Identität zu ermitteln. Verwenden Sie die ID wie <identity-id> im nächsten Schritt.
Verwenden Sie für die lokale Entwicklung den folgenden Befehl, um Ihre eigene Identitäts-ID abzurufen. Sie müssen sich mit az login anmelden, bevor Sie diesen Befehl verwenden.
```
az ad signed-in-user show \
    --query id -o tsv
```
Verwenden Sie für die lokale Entwicklung den folgenden Befehl, um Ihre eigene Identitäts-ID abzurufen. Sie müssen sich mit Connect-AzAccount anmelden, bevor Sie diesen Befehl verwenden.
```
(Get-AzContext).Account.ExtendedProperties.HomeAccountId.Split('.')[0]
```
Bei Verwendung von Bicep, die mit Azure Developer CLI bereitgestellt wird, wird die Identität der Person oder des Diensts, die die Bereitstellung ausführt, auf den principalId Parameter festgelegt.

Die folgende main.parameters.json Variable wird auf die Identität festgelegt, die den Prozess ausführt.
```
"principalId": {
    "value": "${AZURE_PRINCIPAL_ID}"
  },
```
Geben Sie für die Verwendung in Azure eine vom Benutzer zugewiesene verwaltete Identität als Teil des Bicep-Bereitstellungsprozesses an. Erstellen Sie eine vom Benutzer zugewiesene verwaltete Identität getrennt von der Identität, die den Prozess ausführt.
```
resource userAssignedManagedIdentity 'Microsoft.ManagedIdentity/userAssignedIdentities@2018-11-30' = {
  name: managedIdentityName
  location: location
}
```
Führen Sie die hier gezeigten Schritte aus: Suchen Sie die Benutzerobjekt-ID im Azure-Portal.

Weisen Sie die rollenbasierte Zugriffssteuerung der Identität für die Ressourcengruppe zu.

Um Ihre Identitätsberechtigungen für Ihre Ressource über RBAC zu erteilen, weisen Sie eine Rolle mithilfe des Azure CLI-Befehls az Rollenzuweisung zu.

az role assignment create \
    --role "Cognitive Services OpenAI User" \
    --assignee "<identity-id>" \
    --scope "/subscriptions/<subscription-id>/resourceGroups/<resource-group-name>"

Um Ihre Anwendungsberechtigungen für Ihre Azure OpenAI-Ressource über RBAC zu erteilen, weisen Sie eine Rolle mithilfe des Azure PowerShell-Cmdlets New-AzRoleAssignment zu.

New-AzRoleAssignment -ObjectId "<identity-id>" -RoleDefinitionName "Cognitive Services OpenAI User" -Scope "/subscriptions/<subscription-id>/resourceGroups/<resource-group-name>"

Verwenden Sie die folgende Azure OpenAI Bicep-Vorlage, um die Ressource zu erstellen und die Authentifizierung für identityId festzulegen. Bicep erfordert die Rollen-ID. Der in diesem Bicep-Ausschnitt angezeigte name ist nicht die Azure-Rolle. Er ist spezifisch für die Bicep-Bereitstellung.

// main.bicep
param environment string = 'production'

// USER ROLES
module openAiRoleUser 'core/security/role.bicep' = {
    scope: openAiResourceGroup
    name: 'openai-role-user'
    params: {
        principalId: (environment == 'development') ? principalId : userAssignedManagedIdentity 
        principalType: (environment == 'development') ? 'User' : 'ServicePrincipal'
        roleDefinitionId: '5e0bd9bd-7b93-4f28-af87-19fc36ad61bd'
    }
}

Der folgende generische Bicep wird von main.bicep aufgerufen, um eine beliebige Rolle zu erstellen.

// core/security/role.bicep
metadata description = 'Creates a role assignment for an identity.'
param principalId string // passed in from main.bicep identityId

@allowed([
    'Device'
    'ForeignGroup'
    'Group'
    'ServicePrincipal'
    'User'
])
param principalType string = 'ServicePrincipal'
param roleDefinitionId string

resource role 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
    name: guid(subscription().id, resourceGroup().id, principalId, roleDefinitionId)
    properties: {
        principalId: principalId
        principalType: principalType
        roleDefinitionId: resourceId('Microsoft.Authorization/roleDefinitions', roleDefinitionId)
    }
}

Ersetzen Sie gegebenenfalls <identity-id>, <subscription-id> und <resource-group-name> durch Ihre tatsächlichen Werte.

Konfigurieren von Umgebungsvariablen

Um eine Verbindung mit Azure OpenAI herzustellen, muss Ihr Code Ihren Ressourcenendpunkt kennen und möglicherweise andere Umgebungsvariablen benötigen.

Erstellen Sie eine Umgebungsvariable für Ihren Azure OpenAI-Endpunkt.
- AZURE_OPENAI_ENDPOINT: Diese URL ist der Zugriffspunkt für Ihre Azure OpenAI-Ressource.

Erstellen Sie Umgebungsvariablen basierend auf dem Speicherort, an dem Ihre App ausgeführt wird:

Location	Identität	Beschreibung
Lokal	Persönlich	Melden Sie sich für lokale Laufzeiten mit Ihrer persönlichen Identität an, um Ihre Anmeldeinformationen mit einem Tool zu erstellen.
Azure-Cloud	Benutzerseitig zugewiesene verwaltete Identität	Erstellen Sie eine `AZURE_CLIENT_ID` Umgebungsvariable, die die Client-ID der vom Benutzer zugewiesenen verwalteten Identität zum Authentifizieren enthält.

Installieren der Azure Identity-Clientbibliothek

Verwenden Sie den folgenden Link, um die Azure Identity-Clientbibliothek zu installieren.

Installieren Sie die .NET Azure Identity-Clientbibliothek:

dotnet add package Azure.Identity

Installieren Sie die Go Azure Identity-Clientbibliothek:

go get -u github.com/Azure/azure-sdk-for-go/sdk/azidentity

Installieren Sie die Java Azure Identity-Clientbibliothek mit der folgenden POM-Datei:

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>com.azure</groupId>
            <artifactId>azure-identity</artifactId>
            <version>1.10.0</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

Installieren Sie die JavaScript Azure Identity-Clientbibliothek:

npm install --save @azure/identity

Installieren Sie die Python Azure Identity-Clientbibliothek:

pip install azure-identity

Verwendung von DefaultAzureCredential

Die Azure Identity-Bibliothek DefaultAzureCredential ermöglicht es dem Kunden, denselben Code in der lokalen Entwicklungsumgebung und in der Azure Cloud auszuführen.

Weitere Informationen zu DefaultAzureCredential für .NET finden Sie unter Azure Identity-Clientbibliothek für .NET.

using Azure;
using Azure.AI.OpenAI;
using Azure.Identity;
using System;
using static System.Environment;

string endpoint = GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT");

OpenAIClient client = new(new Uri(endpoint), new DefaultAzureCredential());

Weitere Informationen finden Sie über DefaultAzureCredential, für Go unter Azure Identity-Clientbibliothek für Go.

import (
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/ai/azopenai"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
)

func main() {
	dac, err := azidentity.NewDefaultAzureCredential(nil)

	if err != nil {
		log.Fatalf("ERROR: %s", err)
	}

	client, err := azopenai.NewClient(os.Getenv("AZURE_OPENAI_ENDPOINT"), dac, nil)

	if err != nil {
		log.Fatalf("ERROR: %s", err)
	}

	_ = client
}

Weitere Informationen zu DefaultAzureCredential für Java finden Sie unter Azure Identity-Clientbibliothek für Java.

import com.azure.identity.DefaultAzureCredentialBuilder;
import com.azure.ai.openai.OpenAIClient;
import com.azure.ai.openai.OpenAIClientBuilder;

String endpoint = System.getenv("AZURE_OPENAI_ENDPOINT");

DefaultAzureCredential credential = new DefaultAzureCredentialBuilder().build();
OpenAIClient client = new OpenAIClientBuilder()
    .credential(credential)
    .endpoint(endpoint)
    .buildClient();

Weitere Informationen zu DefaultAzureCredential für JavaScript finden Sie unter Azure Identity-Clientbibliothek für JavaScript.

import { DefaultAzureCredential, getBearerTokenProvider } from "@azure/identity";
import { AzureOpenAI } from "openai";

const credential = new DefaultAzureCredential();
const scope = "https://cognitiveservices.azure.com/.default";
const azureADTokenProvider = getBearerTokenProvider(credential, scope);

const endpoint = process.env["AZURE_OPENAI_ENDPOINT"] || "<endpoint>";
const deployment = "<your Azure OpenAI deployment name>";
const apiVersion = "2024-05-01-preview";
const options = { azureADTokenProvider, deployment, apiVersion, endpoint }

const client = new AzureOpenAI(options);

Weitere Informationen zu DefaultAzureCredential für Python finden Sie unter Azure Identity-Clientbibliothek für Python.

import openai
from azure.identity import DefaultAzureCredential, get_bearer_token_provider

token_provider = get_bearer_token_provider(DefaultAzureCredential(), "https://cognitiveservices.azure.com/.default")

openai_client = openai.AzureOpenAI(
    api_version=os.getenv("AZURE_OPENAI_VERSION"),
    azure_endpoint=os.getenv("AZURE_OPENAI_ENDPOINT"),
    azure_ad_token_provider=token_provider
)

Ressourcen

Entwicklerhandbuch für passwortlose Verbindungen

Freigeben über