Erste Schritte mit dem Azure OpenAI-Sicherheitsbaustein

• Eine Python Quart-App, die das paket openai und die API Responses 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 NuGet-Paket Azure.AI.OpenAI benutzt, um Antworten auf Benutzernachrichten zu generieren.

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

Erfahren Sie mehr über Cost im Beispielrepo.

Erfahren Sie mehr über Cost im Beispielrepo.

Erfahren Sie mehr über Cost im Beispielrepo.

Erkunden des Beispielcodes

Während OpenAI und Azure OpenAI Service auf eine common-Python-Clientbibliothek basieren, sind kleine Codeänderungen erforderlich, wenn Azure OpenAI-Endpunkte verwendet werden. 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 Ressourcenumgebungsvariable, um eine AzureDeveloperCliCredential Instanz zu erstellen, die sich mit dem aktuellen Microsoft Entra Mandanten authentifizieren kann.

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

Die Azure Identity-Clientbibliothek stellt Credentials bereit– öffentliche Klassen, die das Azure Core Library-Protokoll TokenCredential implementieren. Eine Anmeldeinformation stellt einen eindeutigen Authentifizierungsfluss zum Abrufen eines Zugriffstokens aus 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 ein ChainedTokenCredential, indem ein ManagedIdentityCredential und ein AzureDeveloperCliCredential verwendet werden.

• Die ManagedIdentityCredential wird für Azure Functions, Azure App Service und Azure Container Apps verwendet. Eine vom Benutzer zugewiesene verwaltete Identität wird unterstützt, indem client_id an ManagedIdentityCredential übergeben wird.
• Dies AzureDeveloperCliCredential wird für die lokale Entwicklung verwendet. Sie wurde zuvor basierend auf dem zu verwendenden Microsoft Entra Mandanten festgelegt.

azure_credential = ChainedTokenCredential(
    user_assigned_managed_identity_credential,
    azure_dev_cli_credential
)

Der folgende Codeausschnitt ruft den Azure OpenAI Token-Provider basierend auf den ausgewählten Azure Anmeldedaten 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: Erfordert einen oder mehrere Geltungsbereiche für Bearer-Token. 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 Umgebungsvariablen AZURE_OPENAI_ENDPOINT und AZURE_OPENAI_CHAT_DEPLOYMENT sowie die zwei azd überprüft, die während der Bereitstellung azd festgelegt werden. Wenn kein Wert vorhanden ist, wird ein Fehler ausgelöst.

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

Dieser Codeausschnitt initialisiert den OpenAI-Client für den /openai/v1/-Endpunkt von Azure und übergibt den Tokenanbieter als api_key. Beim v1-Endpunkt ist kein api_version notwendig.

bp.openai_client = AsyncOpenAI(
    base_url=f"{openai_endpoint.rstrip('/')}/openai/v1/",
    api_key=token_provider,
)

Die folgende Zeile legt den Azure OpenAI-Modellbereitstellungsnamen für die Verwendung in API-Aufrufen fest:

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

Nach Abschluss dieser Funktion ist der Client ordnungsgemäß konfiguriert und kann mit Azure OpenAI-Diensten interagieren.

Streamen von Antworten mithilfe der OpenAI-Antwort-API

Der response_stream verarbeitet den Responses-API-Streamingaufruf in der Route. Das Frontend sendet antwortenförmige input elemente direkt und das Backend leitet sie an responses.stream() weiter.

async def response_stream():
    try:
        async with bp.openai_client.responses.stream(
            model=bp.openai_model,
            input=request_input,
            store=False,
        ) as openai_stream:
            async for event in openai_stream:
                yield json.dumps(event.model_dump(), ensure_ascii=False) + "\n"
    except Exception as e:
        current_app.logger.exception("Responses stream failed")
        yield json.dumps({"error": str(e)}, ensure_ascii=False) + "\n"

Untersuchen des Beispielcodes

.NET Anwendungen basieren auf dem Azure. AI. OpenAI-Clientbibliothek für die Kommunikation mit Azure OpenAI-Diensten, die eine Abhängigkeit von der OpenAIBibliothek akzeptiert. Die Beispiel-App konfiguriert die schlüssellose Authentifizierung mithilfe von 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 von AZURE_CLIENT_IDazd festgelegte Umgebungsvariable, um eine ManagedIdentityCredential-Instanz zu erstellen, die sich über eine benutzerzugewiesene verwaltete Identität authentifizieren 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 Azure Core-Bibliotheksprotokoll TokenCredential implementieren. Eine Anmeldeinformation stellt einen eindeutigen Authentifizierungsfluss zum Abrufen eines Zugriffstokens aus Microsoft Entra ID dar. Diese Anmeldeinformationen können mithilfe von ChainedTokenCredential in eine geordnete Abfolge von Authentifizierungsmechanismen verkettet werden, die durchlaufen werden sollen.

Der folgende Codeausschnitt registriert die AzureOpenAIClient für Abhängigkeitsinjektion und erstellt eine ChainedTokenCredential, indem ein ManagedIdentityCredential und ein AzureDeveloperCliCredential verwendet werden.

• Die ManagedIdentityCredential wird für Azure Functions, Azure App Service und Azure Container Apps verwendet. Eine vom Benutzer zugewiesene verwaltete Identität wird mithilfe der bereitgestellten AZURE_CLIENT_ID für die ManagedIdentityCredential unterstützt.
• Dies AzureDeveloperCliCredential wird für die lokale Entwicklung verwendet. Sie wurde zuvor festgelegt, basierend auf dem Microsoft Entra-Mandanten, 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 das registrierte 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, sind kleine Codeänderungen erforderlich, wenn sie Azure OpenAI-Endpunkte verwenden. 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. Eine Anmeldeinformation stellt einen eindeutigen Authentifizierungsfluss zum Abrufen eines Zugriffstokens aus Microsoft Entra ID dar. Diese Anmeldeinformationen können mithilfe eines ChainedTokenCredential verkettet werden, um eine sortierte Sequenz von Authentifizierungsmechanismen zu bilden, 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 stellt das ./src/azure-authentication.ts mehrere Funktionen bereit, um eine schlüssellose Authentifizierung für Azure OpenAI bereitzustellen.

Die erste Funktion, getChainedCredential(), gibt die ersten gültigen Azure-Anmeldeinformationen, die in der Kette gefunden werden, 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. Wenn ein Entwickler sich mit der Azure Developer CLI mit azd auth login anmeldet, wird sie eingerichtet.

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 Endpunkt Azure Cognitive Services bereitstellt.

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

Der vorangehende Codeausschnitt verwendet getBearerTokenProvider, um die Anmeldeinformationen und den Bereich zu übernehmen, und gibt dann ein Callback zurück, das ein Bearer-Token bereitstellt.

Erstellen authentifizierter Azure OpenAI-Client

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 korrekt abgegrenzten Tokens und erstellt den AzureOpenAI Client.

Streamen der Chatantwort mit Azure OpenAI

Verwenden Sie den folgenden Fastify-Routenhandler in ./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 Datenstromteile von Azure OpenAI zurückgegeben werden, werden sie an den Client gesendet.

Wenn Ihr Problem nicht gelöst wurde, melden Sie Ihr Problem im Issues-Bereich des Repositorys.

Nächste Schritte

Wenn Ihr Problem nicht gelöst wurde, melden Sie Ihr Problem im Issues-Bereich des Repositorys.

Wenn Ihr Problem nicht gelöst wurde, melden Sie Ihr Problem im Issues-Bereich des Repositorys.