Erste Schritte mit dem Azure OpenAI-Sicherheitsbaustein

• Das Microsoft KI-Chat-Protokoll bietet standardisierte API-Verträge über KI-Lösungen und Sprachen hinweg. Die Chat-App entspricht dem Microsoft KI-Chat-Protokoll, mit dem die Evaluierungs-App für jede Chat-App ausgeführt werden kann, die dem Protokoll entspricht.
• Ein Python Quart , das das openai Paket verwendet, um Antworten auf Benutzernachrichten zu generieren.
• Ein einfaches HTML/JavaScript-Frontend, das Antworten aus dem Back-End mithilfe von JSON-Zeilen über einen ReadableStream streamt.

• Eine Blazor-Web-App, die das Azure.AI.OpenAI NuGet-Paket verwendet, um Antworten auf Benutzernachrichten zu generieren.

• Eine TypeScript-Web-App, die das openai npm-Paket verwendet, um Antworten auf Benutzernachrichten zu generieren.

Weitere Informationen zu den Kosten im Beispielrepository finden Sie hier.

Weitere Informationen zu den Kosten im Beispielrepository finden Sie hier.

Weitere Informationen zu den Kosten im Beispielrepository finden Sie hier.

Erkunden des Beispielcodes

Während OpenAI und Azure OpenAI Service auf eine allgemeine Python-Clientbibliothek angewiesen sind, werden kleine Codeänderungen bei Verwendung von Azure OpenAI-Endpunkten benötigt. Sehen wir uns an, wie in diesem Beispiel die schlüssellose Authentifizierung mit Microsoft Entra ID konfiguriert und mit Azure OpenAI kommuniziert wird.

Konfigurieren der Authentifizierung mit verwalteter Identität

In diesem Beispiel beginnt die Datei mit der Konfiguration der src\quartapp\chat.py schlüssellosen Authentifizierung.

Der folgende Codeausschnitt verwendet das Modul azure.identity.aio , um einen asynchronen Microsoft Entra-Authentifizierungsfluss zu erstellen.

Der folgende Codeausschnitt verwendet die AZURE_CLIENT_IDazd Umgebungsvariable, um eine ManagedIdentityCredential-Instanz zu erstellen, die über vom Benutzer zugewiesene verwaltete Identität authentifiziert werden kann.

user_assigned_managed_identity_credential = ManagedIdentityCredential(client_id=os.getenv("AZURE_CLIENT_ID")) 

Der folgende Codeausschnitt verwendet AZURE_TENANT_IDazd die Ressourcenumgebungsvariable, um eine AzureDeveloperCliCredential-Instanz zu erstellen, die mit dem aktuellen Microsoft Entra-Mandanten authentifiziert werden kann.

azure_dev_cli_credential = AzureDeveloperCliCredential(tenant_id=os.getenv("AZURE_TENANT_ID"), process_timeout=60)  

Die Azure Identity-Clientbibliothek stellt Anmeldeinformationen bereit – öffentliche Klassen, die das TokenCredential-Protokoll der Azure Core-Bibliothek implementieren. Anmeldeinformationen stellen einen eindeutigen Authentifizierungsfluss zum Abrufen eines Zugriffstokens aus der Microsoft Entra-ID dar. Diese Anmeldedaten können miteinander verkettet werden, um eine geordnete Abfolge von Authentifizierungsmechanismen zu bilden, die versucht werden sollen.

Der folgende Codeausschnitt erstellt eine using a ChainedTokenCredentialManagedIdentityCredential und eine AzureDeveloperCliCredential:

• Dies ManagedIdentityCredential wird für Azure-Funktionen und Azure-App-Dienst verwendet. Eine vom Benutzer zugewiesene verwaltete Identität wird durch übergeben an client_idManagedIdentityCredential.
• Dies AzureDeveloperCliCredential wird für die lokale Entwicklung verwendet. Sie wurde zuvor basierend auf dem Microsoft Entra-Mandanten festgelegt, der verwendet werden soll.

azure_credential = ChainedTokenCredential(
    user_assigned_managed_identity_credential,
    azure_dev_cli_credential
)

Der folgende Codeausschnitt ruft den Azure OpenAI-Tokenanbieter basierend auf den ausgewählten Azure-Anmeldeinformationen ab. Dieser Wert wird durch Aufrufen der azure.identity.aio.get_bearer_token_provider mit zwei Argumenten abgerufen:

• azure_credential: Die ChainedTokenCredential zuvor erstellte Instanz, um die Anforderung zu authentifizieren.

• https://cognitiveservices.azure.com/.default: Erforderlich für einen oder mehrere Bearertokenbereiche. In diesem Fall der Azure Cognitive Services-Endpunkt .

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

In den folgenden Zeilen werden die erforderlichen AZURE_OPENAI_ENDPOINT Und AZURE_OPENAI_CHATGPT_DEPLOYMENTazd Ressourcenumgebungsvariablen überprüft, die während der azd App-Bereitstellung bereitgestellt werden. Wenn kein Wert vorhanden ist, wird ein Fehler ausgelöst.

if not os.getenv("AZURE_OPENAI_ENDPOINT"):
    raise ValueError("AZURE_OPENAI_ENDPOINT is required for Azure OpenAI")
if not os.getenv("AZURE_OPENAI_CHATGPT_DEPLOYMENT"):
    raise ValueError("AZURE_OPENAI_CHATGPT_DEPLOYMENT is required for Azure OpenAI")

Dieser Codeausschnitt initialisiert den Azure OpenAI-Client, legt die api_versionParameter und azure_endpointazure_ad_token_provider(client_args) fest:

bp.openai_client = AsyncAzureOpenAI(
    api_version=os.getenv("AZURE_OPENAI_API_VERSION") or "2024-02-15-preview",
    azure_endpoint=os.getenv("AZURE_OPENAI_ENDPOINT"),
    azure_ad_token_provider=token_provider,
)  

In der folgenden Zeile wird der Bereitstellungsname des Azure OpenAI-Modells für die Verwendung in API-Aufrufen festgelegt:

bp.openai_model = os.getenv("AZURE_OPENAI_CHATGPT_DEPLOYMENT")

Sobald diese Funktion abgeschlossen ist, ist der Client ordnungsgemäß konfiguriert und bereit für die Interaktion mit Azure OpenAI-Diensten.

Antwortdatenstrom mit dem OpenAI-Client und -Modell

Der response_stream Chatabschlussanruf wird in der Route behandelt. Der folgende Codeausschnitt zeigt, wie openai_client und model verwendet wird.

async def response_stream():
    # This sends all messages, so API request may exceed token limits
    all_messages = [
        {"role": "system", "content": "You are a helpful assistant."},
    ] + request_messages

    chat_coroutine = bp.openai_client.chat.completions.create(
        # Azure Open AI takes the deployment name as the model name
        model=bp.openai_model,
        messages=all_messages,
        stream=True,
    )

Untersuchen des Beispielcodes

.NET-Anwendungen basieren auf der Azure.AI.OpenAI-Clientbibliothek für die Kommunikation mit Azure OpenAI-Diensten, die eine Abhängigkeit von der OpenAI-Bibliothek benötigen. Die Beispiel-App konfiguriert die schlüssellose Authentifizierung mithilfe der Microsoft Entra-ID für die Kommunikation mit Azure OpenAI.

Konfigurieren der Authentifizierung und Dienstregistrierung

In diesem Beispiel wird die schlüssellose Authentifizierung in der program.cs Datei konfiguriert. Der folgende Codeausschnitt verwendet die Umgebungsvariable, die AZURE_CLIENT_IDazd festgelegt wurde, um eine ManagedIdentityCredential-Instanz zu erstellen, die über vom Benutzer zugewiesene verwaltete Identität authentifiziert werden kann.

var userAssignedIdentityCredential = 
    new ManagedIdentityCredential(builder.Configuration.GetValue<string>("AZURE_CLIENT_ID"));

Der folgende Codeausschnitt verwendet die Umgebungsvariable, die AZURE_TENANT_IDazd festgelegt wurde, um eine AzureDeveloperCliCredential-Instanzazdzu erstellen, die lokal mithilfe des angemeldeten Kontos authentifiziert werden kann.

var azureDevCliCredential = new AzureDeveloperCliCredential(
    new AzureDeveloperCliCredentialOptions()
    { 
        TenantId = builder.Configuration.GetValue<string>("AZURE_TENANT_ID") 
    });

Die Azure Identity-Clientbibliothek stellt Anmeldeinformationsklassen bereit, die das TokenCredential-Protokoll der Azure Core-Bibliothek implementieren. Anmeldeinformationen stellen einen eindeutigen Authentifizierungsfluss zum Abrufen eines Zugriffstokens aus der Microsoft Entra-ID dar. Diese Anmeldeinformationen können mithilfe ChainedTokenCredential einer sortierten Abfolge von Authentifizierungsmechanismen verkettet werden, die versucht werden sollen.

Der folgende Codeausschnitt registriert die AzureOpenAIClient Abhängigkeitsinjektion und erstellt eine ChainedTokenCredential Verwendung und ManagedIdentityCredential eine AzureDeveloperCliCredential:

• Dies ManagedIdentityCredential wird für Azure-Funktionen und Azure-App-Dienst verwendet. Eine vom Benutzer zugewiesene verwaltete Identität wird mithilfe der AZURE_CLIENT_ID vom Benutzer bereitgestellten Identität ManagedIdentityCredentialunterstützt.
• Dies AzureDeveloperCliCredential wird für die lokale Entwicklung verwendet. Sie wurde zuvor basierend auf dem Microsoft Entra-Mandanten festgelegt, der verwendet werden soll.

builder.Services.AddAzureClients(
    clientBuilder => {
        clientBuilder.AddClient<AzureOpenAIClient, AzureOpenAIClientOptions>((options, _, _)
            => new AzureOpenAIClient(
                new Uri(endpoint),
                new ChainedTokenCredential(
                    userAssignedIdentityCredential, azureDevCliCredential), options));
    });

Abrufen von Chatabschlussen mithilfe des Azure OpenAI-Clients

Die Blazor-Web-App fügt die registrierten AzureOpenAIClient am Anfang der Home.Razor Komponente ein:

@inject AzureOpenAIClient azureOpenAIClient

Wenn der Benutzer das Formular übermittelt, sendet der Benutzer seine AzureOpenAIClient Aufforderung an das OpenAI-Modell, um einen Abschluss zu generieren:

ChatClient chatClient = azureOpenAIClient.GetChatClient("gpt-4o-mini");

messages.Add(new UserChatMessage(model.UserMessage));

ChatCompletion completion = await chatClient.CompleteChatAsync(messages);
    messages.Add(new SystemChatMessage(completion.Content[0].Text));

Untersuchen des Beispielcodes

Während OpenAI und Azure OpenAI Service auf eine Openai (allgemeine JavaScript-Clientbibliothek) angewiesen sind, werden kleine Codeänderungen bei Verwendung von Azure OpenAI-Endpunkten benötigt. Sehen wir uns an, wie in diesem Beispiel die schlüssellose Authentifizierung mit Microsoft Entra ID konfiguriert und mit Azure OpenAI kommuniziert wird.

Schlüssellose Authentifizierung für jede Umgebung

Die Azure Identity-Clientbibliothek stellt Anmeldeinformationsklassen bereit, die das TokenCredential-Protokoll der Azure Core-Bibliothek implementieren. Anmeldeinformationen stellen einen eindeutigen Authentifizierungsfluss zum Abrufen eines Zugriffstokens aus der Microsoft Entra-ID dar. Diese Anmeldeinformationen können mithilfe ChainedTokenCredential einer sortierten Abfolge von Authentifizierungsmechanismen verkettet werden, die versucht werden sollen. Auf diese Weise können Sie denselben Code sowohl in Produktions- als auch in lokalen Entwicklungsumgebungen bereitstellen.

Konfigurieren der Authentifizierung mit verwalteter Identität

In diesem Beispiel bietet die ./src/azure-authentication.ts Funktion mehrere Funktionen, um eine schlüssellose Authentifizierung für Azure OpenAI bereitzustellen.

Die erste Funktion , getChainedCredential()gibt die ersten gültigen Azure-Anmeldeinformationen in der Kette zurück.

function getChainedCredential() {

    return new ChainedTokenCredential(
        new ManagedIdentityCredential(process.env.AZURE_CLIENT_ID!), 
        new AzureDeveloperCliCredential({
            tenantId: process.env.AZURE_TENANT_ID! ? process.env.AZURE_TENANT_ID! : undefined
          })
    );
}

• ManagedIdentityCredential wird zuerst versucht. Sie ist mit der AZURE_CLIENT_ID Umgebungsvariable in der Produktionslaufzeit eingerichtet und kann über vom Benutzer zugewiesene verwaltete Identität authentifiziert werden.
• AzureDeveloperCliCredential wird zweitens versucht. Sie wird eingerichtet, wenn sich eine Entwicklung mit Azure CLI az loginanmeldet.

Bearertoken für OpenAI abrufen

Die zweite Funktion in ./src/azure-authentication.ts ist getTokenProvider(), die einen Rückruf zurückgibt, der ein Bearertoken für den Azure Cognitive Services-Endpunkt bereitstellt.

function getTokenProvider(): () => Promise<string> {
    const credential  = getChainedCredential();
    const scope = "https://cognitiveservices.azure.com/.default";
    return getBearerTokenProvider(credential, scope);
}

Der vorangehende Codeausschnitt verwendet getBearerTokenProvider die Anmeldeinformationen und den Bereich, und gibt dann einen Rückruf zurück, der ein Bearertoken bereitstellt.

Erstellen eines authentifizierten Azure OpenAI-Clients

Die dritte Funktion in ./src/azure-authentication.ts ist getOpenAiClient(), die den Azure OpenAI-Client zurückgibt.

export function getOpenAiClient(): AzureOpenAI | undefined{
    try {

        if (!process.env.AZURE_OPENAI_ENDPOINT) {
            throw new Error("AZURE_OPENAI_ENDPOINT is required for Azure OpenAI");
        }
        if (!process.env.AZURE_OPENAI_CHAT_DEPLOYMENT) {
            throw new Error("AZURE_OPENAI_CHAT_DEPLOYMENT is required for Azure OpenAI");
        }

        const options = { 
            azureADTokenProvider: getTokenProvider(), 
            deployment: process.env.AZURE_OPENAI_CHAT_DEPLOYMENT!, 
            apiVersion: process.env.AZURE_OPENAI_API_VERSION! || "2024-02-15-preview",
            endpoint: process.env.AZURE_OPENAI_ENDPOINT!
        }

        // Create the Asynchronous Azure OpenAI client
        return new AzureOpenAI (options);

    } catch (error) {
        console.error('Error getting Azure OpenAI client: ', error);
    }
}

Dieser Code verwendet die Optionen, einschließlich des ordnungsgemäß bereichsbezogenen Tokens und erstellt den AzureOpenAI Client.

Chatantwort mit Azure OpenAI streamen

Verwenden Sie den folgenden Fastify-Routenhandler, ./src/openai-chat-api.ts um eine Nachricht an Azure OpenAI zu senden und die Antwort zu streamen.

import { FastifyReply, FastifyRequest } from 'fastify';
import { AzureOpenAI } from "openai";
import { getOpenAiClient } from './azure-authentication.js';
import { ChatCompletionChunk, ChatCompletionMessageParam } from 'openai/resources/chat/completions';

interface ChatRequestBody {
    messages: ChatCompletionMessageParam [];
  }

export async function chatRoute (request: FastifyRequest<{ Body: ChatRequestBody }>, reply: FastifyReply) {

    const requestMessages: ChatCompletionMessageParam[] = request?.body?.messages;
    const openaiClient: AzureOpenAI | undefined = getOpenAiClient();

    if (!openaiClient) {
      throw new Error("Azure OpenAI client is not configured");
    }

    const allMessages = [
      { role: "system", content: "You are a helpful assistant."},
      ...requestMessages
    ] as ChatCompletionMessageParam [];

    const chatCompletionChunks = await openaiClient.chat.completions.create({
      // Azure Open AI takes the deployment name as the model name
      model: process.env.AZURE_OPENAI_CHAT_DEPLOYMENT_MODEL || "gpt-4o-mini",
      messages: allMessages,
      stream: true

    })
    reply.raw.setHeader('Content-Type', 'text/html; charset=utf-8');
    reply.raw.setHeader('Cache-Control', 'no-cache');
    reply.raw.setHeader('Connection', 'keep-alive');
    reply.raw.flushHeaders();

    for await (const chunk of chatCompletionChunks as AsyncIterable<ChatCompletionChunk>) {
      for (const choice of chunk.choices) {
        reply.raw.write(JSON.stringify(choice) + "\n")
      }
    }

    reply.raw.end()

}

Die Funktion ruft die Chatunterhaltung einschließlich früherer Nachrichten ab und sendet sie an Azure OpenAI. Wenn die Datenströme von Azure OpenAI zurückgegeben werden, werden die Daten an den Client gesendet.

Wenn Ihr Problem nicht behoben ist, protokollieren Sie Ihr Problem bei den Problemen des Repositorys.

Nächste Schritte

Wenn Ihr Problem nicht behoben ist, protokollieren Sie Ihr Problem bei den Problemen des Repositorys.

Wenn Ihr Problem nicht behoben ist, protokollieren Sie Ihr Problem bei den Problemen des Repositorys.