Kom igång med byggblocket Azure OpenAI-säkerhet

• En Python Quart-app som använder paketet openai och api:et Responses för att generera svar på användarmeddelanden.
• En grundläggande HTML-/JavaScript-klientdel som strömmar svar från serverdelen med hjälp av JSON-rader via en ReadableStream.

• En Blazor-webbapp som använder Azure. AI. OpenAI NuGet-paket för att generera svar på användarmeddelanden.

• En TypeScript-webbapp som använder OpenAI npm-paketet för att generera svar på användarmeddelanden.

Läs mer om kostnad i exempelrepo.

Läs mer om kostnad i exempelrepo.

Läs mer om kostnad i exempelrepo.

Utforska exempelkoden

OpenAI och Azure OpenAI Service förlitar sig på ett gemensamt Python-klientbibliotek, men små kodändringar krävs när du använder Azure OpenAI-slutpunkter. Nu ska vi se hur det här exemplet konfigurerar nyckellös autentisering med Microsoft Entra ID och kommunicerar med Azure OpenAI.

Konfigurera autentisering med hanterad identitet

I det här exemplet src/quartapp/chat.py börjar filen med att konfigurera nyckellös autentisering.

Följande kodfragment använder modulen azure.identity.aio för att skapa ett asynkront Microsoft Entra autentiseringsflöde.

Följande kodfragment använder AZURE_CLIENT_IDazd miljövariabeln för att skapa en ManagedIdentityCredential-instans som kan autentisera via användartilldelad hanterad identitet.

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

Följande kodfragment använder AZURE_TENANT_IDazd resursmiljövariabler för att skapa en AzureDeveloperCliCredential instans som kan autentisera med den aktuella Microsoft Entra tenant.

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

Klientbiblioteket för Azure Identity innehåller credentials – offentliga klasser som implementerar Azure Core-bibliotekets TokenCredential protokoll. En autentiseringsuppgift representerar ett distinkt autentiseringsflöde för att hämta en åtkomsttoken från Microsoft Entra ID. Dessa autentiseringsuppgifter kan kopplas samman för att bilda en ordnad sekvens med autentiseringsmekanismer som ska försökas.

Följande kodfragment skapar en ChainedTokenCredential med hjälp av en ManagedIdentityCredential och en AzureDeveloperCliCredential:

• ManagedIdentityCredential används för Azure Functions, Azure App Service och Azure Container Apps. En användartilldelad hanterad identitet stöds genom att skicka client_id till ManagedIdentityCredential.
• AzureDeveloperCliCredential Används för lokal utveckling. Den angavs tidigare baserat på den Microsoft Entra klientorganisation som ska användas.

azure_credential = ChainedTokenCredential(
    user_assigned_managed_identity_credential,
    azure_dev_cli_credential
)

Följande kodfragment hämtar Azure OpenAI-tokenleverantören baserat på den valda Azure-autentiseringsuppgiften. Det här värdet erhålls genom att anropa azure.identity.aio.get_bearer_token_provider med två argument:

• azure_credential: Den ChainedTokenCredential instans som skapades tidigare för att autentisera begäran.

• https://cognitiveservices.azure.com/.default: Ett eller flera bärartoken-omfång krävs. I det här fallet slutpunkten Azure Cognitive Services.

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

Följande rader söker efter de obligatoriska AZURE_OPENAI_ENDPOINT och AZURE_OPENAI_CHAT_DEPLOYMENT, två azd miljövariabler som anges under azd hanteringen. Ett fel utlöses om ett värde inte finns.

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")

Det här kodfragmentet initierar OpenAI-klienten mot Azure /openai/v1/ slutpunkt och skickar tokenprovidern som api_key. api_version behövs inte med v1-slutpunkten:

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

Följande rad anger distributionsnamnet för Azure OpenAI-modell för användning i API-anrop:

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

När den här funktionen har slutförts är klienten korrekt konfigurerad och redo att interagera med Azure OpenAI-tjänster.

Strömma svar med openAI-svars-API:et

response_stream hanterar strömningsanropet för svars-API:et på rutten. Klientdelen skickar svarsformade input objekt direkt, och serverdelen vidarebefordrar dem till responses.stream():

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"

Utforska exempelkoden

.NET program förlitar sig på Azure. AI. OpenAI-klientbibliotek för att kommunicera med Azure OpenAI-tjänster, som är beroende av biblioteket OpenAI. Exempelappen konfigurerar nyckellös autentisering med hjälp av Microsoft Entra ID för att kommunicera med Azure OpenAI.

Konfigurera autentisering och tjänstregistrering

I det här exemplet konfigureras nyckellös autentisering i program.cs filen. Följande kodfragment använder miljövariabeln AZURE_CLIENT_ID som anges av azd för att skapa en ManagedIdentityCredential-instans som kan autentisera via användartilldelad hanterad identitet.

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

Följande kodfragment använder AZURE_TENANT_ID miljövariabeln som anges av azd för att skapa en AzureDeveloperCliCredential-instansazdsom kan autentisera lokalt med kontot som är inloggad på .

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

Klientbiblioteket Azure Identity innehåller autentiseringsklasser som implementerar Azure Core-bibliotekets protokoll TokenCredential. En autentiseringsuppgift representerar ett distinkt autentiseringsflöde för att hämta en åtkomsttoken från Microsoft Entra ID. Dessa autentiseringsuppgifter kan kopplas samman med hjälp av ChainedTokenCredential för att bilda en ordnad sekvens av autentiseringsmekanismer som ska försökas.

Följande kodfragment registrerar AzureOpenAIClient för beroendeinmatning och skapar en ChainedTokenCredential med hjälp av en ManagedIdentityCredential och en AzureDeveloperCliCredential:

• ManagedIdentityCredential används för Azure Functions, Azure App Service och Azure Container Apps. En användartilldelad hanterad identitet stöds genom AZURE_CLIENT_ID som gavs till ManagedIdentityCredential.
• AzureDeveloperCliCredential Används för lokal utveckling. Den angavs tidigare baserat på den Microsoft Entra klientorganisation som ska användas.

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

Få chatten slutförd med hjälp av Azure OpenAI-klienten

Blazor-webbappen injicerar den registrerade AzureOpenAIClient överst i Home.Razor-komponenten.

@inject AzureOpenAIClient azureOpenAIClient

När användaren skickar formuläret skickar meddelandet AzureOpenAIClient till OpenAI-modellen för att generera ett slutförande:

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));

Utforska exempelkoden

Även om OpenAI och Azure OpenAI Service förlitar sig på ett openai (vanligt JavaScript-klientbibliotek), krävs små kodändringar när du använder Azure OpenAI-slutpunkter. Nu ska vi se hur det här exemplet konfigurerar nyckellös autentisering med Microsoft Entra ID och kommunicerar med Azure OpenAI.

Nyckellös autentisering för varje miljö

Klientbiblioteket Azure Identity innehåller autentiseringsklasser som implementerar Azure Core-bibliotekets protokoll TokenCredential. En autentiseringsuppgift representerar ett distinkt autentiseringsflöde för att hämta en åtkomsttoken från Microsoft Entra ID. Dessa autentiseringsuppgifter kan kopplas samman med hjälp av en ChainedTokenCredential för att bilda en ordnad sekvens med autentiseringsmekanismer som ska försökas. På så sätt kan du distribuera samma kod i både produktionsmiljöer och lokala utvecklingsmiljöer.

Konfigurera autentisering med hanterad identitet

I det här exemplet innehåller ./src/azure-authentication.ts flera funktioner för att tillhandahålla nyckellös autentisering för Azure OpenAI.

Den första funktionen, getChainedCredential(), returnerar den första giltiga Azure autentiseringsuppgifter som finns i kedjan.

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 försöks först. Den har konfigurerats med miljövariabeln AZURE_CLIENT_ID i produktionskörningen och kan autentiseras via användartilldelad hanterad identitet.
• AzureDeveloperCliCredential försöks som nummer två. Den konfigureras när en utvecklare loggar in med cli:et Azure Developer med hjälp av azd auth login.

Hämta ägartoken för OpenAI

Den andra funktionen i ./src/azure-authentication.ts är getTokenProvider(), som returnerar en callback som tillhandahåller en bearertoken som är begränsad till Azure Cognitive Services slutpunkt.

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

Föregående kodfragment använder getBearerTokenProvider för att ta autentiseringsuppgifterna och omfånget och returnerar sedan ett återanrop som ger en bärartoken.

Skapa autentiserad Azure OpenAI-klient

Den tredje funktionen i ./src/azure-authentication.ts är getOpenAiClient(), som returnerar Azure OpenAI-klienten.

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);
    }
}

Den här koden tar alternativen, inklusive den korrekt begränsade token, och skapar AzureOpenAI klienten

Stream chat-svar med Azure OpenAI

Använd följande Fastify-routningshanterare i ./src/openai-chat-api.ts för att skicka ett meddelande till Azure OpenAI och strömma svaret.

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()

}

Funktionen hämtar chattkonversationen, inklusive eventuella tidigare meddelanden, och skickar dem till Azure OpenAI. När dataströmsegmenten returneras från Azure OpenAI skickas de till klienten.

Om problemet inte åtgärdas kan du registrera ditt problem på lagringsplatsens Issues.

Nästa steg

Om problemet inte åtgärdas kan du registrera ditt problem på lagringsplatsens Issues.

Om problemet inte åtgärdas kan du registrera ditt problem på lagringsplatsens Issues.