Introduzione al blocco predefinito di sicurezza Di Azure OpenAI

• Microsoft AI Chat Protocol offre contratti API standardizzati tra soluzioni e linguaggi di intelligenza artificiale. L'app chat è conforme al protocollo Microsoft AI Chat Protocol, che consente l'esecuzione dell'app di valutazione su qualsiasi app di chat conforme al protocollo.
• Python Quart che usa il openai pacchetto per generare risposte ai messaggi utente.
• Front-end HTML/JavaScript di base che trasmette le risposte dal back-end usando righe JSON su un flusso leggibile.

• Un'app Web Blazor che usa il pacchetto NuGet Azure.AI.OpenAI per generare risposte ai messaggi utente.

• Un'app Web TypeScript che usa il pacchetto npm openai per generare risposte ai messaggi utente.

Altre informazioni sui costi nel repository di esempio.

Altre informazioni sui costi nel repository di esempio.

Altre informazioni sui costi nel repository di esempio.

Esplorazione del codice di esempio

Mentre OpenAI e il servizio Azure OpenAI si basano su una libreria client Python comune, quando si usano gli endpoint OpenAI di Azure sono necessarie piccole modifiche al codice. Vediamo come questo esempio configura l'autenticazione senza chiave con l'ID Entra Di Microsoft e comunica con Azure OpenAI.

Configurare l'autenticazione con l'identità gestita

In questo esempio il src\quartapp\chat.py file inizia con la configurazione dell'autenticazione senza chiave.

Il frammento di codice seguente usa il modulo azure.identity.aio per creare un flusso di autenticazione asincrono di Microsoft Entra.

Il frammento di codice seguente usa la AZURE_CLIENT_IDazd variabile di ambiente per creare un'istanza managedIdentityCredential in grado di eseguire l'autenticazione tramite l'identità gestita assegnata dall'utente.

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

Il frammento di codice seguente usa la AZURE_TENANT_IDazd variabile di ambiente delle risorse per creare un'istanza di AzureDeveloperCliCredential in grado di eseguire l'autenticazione con il tenant Microsoft Entra corrente.

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

La libreria client di Identità di Azure fornisce le credenziali, ovvero classi pubbliche che implementano il protocollo TokenCredential della libreria Core di Azure. Una credenziale rappresenta un flusso di autenticazione distinto per l'acquisizione di un token di accesso da Microsoft Entra ID. Queste credenziali si possono concatenare per formare una sequenza ordinata di meccanismi di autenticazione da tentare.

Il frammento di codice seguente crea un ChainedTokenCredential oggetto utilizzando un ManagedIdentityCredential e un AzureDeveloperCliCredential:

• Viene ManagedIdentityCredential usato per Funzioni di Azure e app Azure Servizio. Un'identità gestita assegnata dall'utente è supportata passando a client_idManagedIdentityCredential.
• Viene AzureDeveloperCliCredential utilizzato per lo sviluppo locale. È stato impostato in precedenza in base al tenant di Microsoft Entra da usare.

azure_credential = ChainedTokenCredential(
    user_assigned_managed_identity_credential,
    azure_dev_cli_credential
)

Il frammento di codice seguente ottiene il provider di token OpenAI di Azure in base alle credenziali di Azure selezionate. Questo valore viene ottenuto chiamando il azure.identity.aio.get_bearer_token_provider con due argomenti:

• azure_credential ChainedTokenCredential: istanza creata in precedenza per autenticare la richiesta.

• https://cognitiveservices.azure.com/.default: obbligatorio uno o più ambiti di token di connessione. In questo caso, l'endpoint di Servizi cognitivi di Azure.

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

Le righe seguenti controllano le variabili di ambiente necessarie AZURE_OPENAI_ENDPOINT e AZURE_OPENAI_CHATGPT_DEPLOYMENTazd di risorse di cui viene effettuato il provisioning durante azd la distribuzione dell'app. Se un valore non è presente, viene generato un errore.

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

Questo frammento di codice inizializza il client OpenAI di Azure, impostando i api_versionparametri , azure_endpointe azure_ad_token_provider (client_args):

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

La riga seguente imposta il nome di distribuzione del modello OpenAI di Azure da usare nelle chiamate API:

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

Al termine di questa funzione, il client è configurato correttamente e pronto per interagire con i servizi OpenAI di Azure.

Flusso di risposta con il client OpenAI e il modello

response_stream Gestisce la chiamata di completamento della chat nella route. Il frammento di codice seguente mostra come openai_client e model vengono usati.

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

Esplorare il codice di esempio

Le applicazioni .NET si basano sulla libreria client Azure.AI.OpenAI per comunicare con i servizi OpenAI di Azure, che dipendono dalla libreria OpenAI . L'app di esempio configura l'autenticazione senza chiave usando Microsoft Entra ID per comunicare con Azure OpenAI.

Configurare l'autenticazione e la registrazione del servizio

In questo esempio l'autenticazione senza chiave viene configurata nel program.cs file . Il frammento di codice seguente usa la AZURE_CLIENT_ID variabile di ambiente impostata da azd per creare un'istanza managedIdentityCredential in grado di eseguire l'autenticazione tramite l'identità gestita assegnata dall'utente.

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

Il frammento di codice seguente usa la AZURE_TENANT_ID variabile di ambiente impostata da azd per creare un'istanza di AzureDeveloperCliCredential in grado di autenticarsi localmente usando l'account connesso a azd.

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

La libreria client di Identità di Azure fornisce classi di credenziali che implementano il protocollo TokenCredential della libreria Core di Azure. Una credenziale rappresenta un flusso di autenticazione distinto per l'acquisizione di un token di accesso da Microsoft Entra ID. Queste credenziali possono essere concatenate usando ChainedTokenCredential per formare una sequenza ordinata di meccanismi di autenticazione da tentare.

Il frammento di codice seguente registra per l'inserimento AzureOpenAIClient delle dipendenze e crea un ChainedTokenCredential oggetto usando un ManagedIdentityCredential e un AzureDeveloperCliCredential:

• Viene ManagedIdentityCredential usato per Funzioni di Azure e app Azure Servizio. Un'identità gestita assegnata dall'utente è supportata usando l'oggetto AZURE_CLIENT_ID fornito a ManagedIdentityCredential.
• Viene AzureDeveloperCliCredential utilizzato per lo sviluppo locale. È stato impostato in precedenza in base al tenant di Microsoft Entra da usare.

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

Ottenere i completamenti della chat usando il client OpenAI di Azure

L'app Web Blazor inserisce l'oggetto registrato AzureOpenAIClient nella parte superiore del Home.Razor componente:

@inject AzureOpenAIClient azureOpenAIClient

Quando l'utente invia il modulo, invia AzureOpenAIClient la richiesta al modello OpenAI di generare un completamento:

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

Esplorare il codice di esempio

Mentre OpenAI e il servizio Azure OpenAI si basano su una libreria client Openai (comune libreria client JavaScript), sono necessarie piccole modifiche al codice quando si usano gli endpoint OpenAI di Azure. Vediamo come questo esempio configura l'autenticazione senza chiave con l'ID Entra Di Microsoft e comunica con Azure OpenAI.

Autenticazione senza chiave per ogni ambiente

La libreria client di Identità di Azure fornisce classi di credenziali che implementano il protocollo TokenCredential della libreria Core di Azure. Una credenziale rappresenta un flusso di autenticazione distinto per l'acquisizione di un token di accesso da Microsoft Entra ID. Queste credenziali possono essere concatenate usando ChainedTokenCredential per formare una sequenza ordinata di meccanismi di autenticazione da tentare. In questo modo è possibile distribuire lo stesso codice sia in ambienti di produzione che in ambienti di sviluppo locali.

Configurare l'autenticazione con l'identità gestita

In questo esempio, ./src/azure-authentication.ts fornisce diverse funzioni per fornire l'autenticazione senza chiave ad Azure OpenAI.

La prima funzione, getChainedCredential(), restituisce la prima credenziale di Azure valida trovata nella catena.

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 viene tentata per prima. Viene configurato con la variabile di ambiente AZURE_CLIENT_ID nel runtime di produzione ed è in grado di eseguire l'autenticazione tramite l'identità gestita assegnata dall'utente.
• Il tentativo di AzureDeveloperCliCredential è il secondo. Viene configurato quando uno sviluppo accede con l'interfaccia della riga di comando az logindi Azure.

Ottenere il token di connessione per OpenAI

La seconda funzione in ./src/azure-authentication.ts è getTokenProvider(), che restituisce un callback che fornisce un token di connessione con ambito all'endpoint di Servizi cognitivi di Azure.

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

Il frammento di codice precedente usa getBearerTokenProvider per accettare le credenziali e l'ambito, quindi restituisce un callback che fornisce un token di connessione.

Creare un client Azure OpenAI autenticato

La terza funzione in ./src/azure-authentication.ts è getOpenAiClient(), che restituisce il client OpenAI di Azure.

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

Questo codice accetta le opzioni, incluso il token con ambito corretto, e crea il AzureOpenAI client

Rispondere alla chat di streaming con Azure OpenAI

Usare il gestore di route Fastify seguente in per ./src/openai-chat-api.ts inviare un messaggio ad Azure OpenAI e trasmettere la risposta.

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

}

La funzione ottiene la conversazione di chat, inclusi i messaggi precedenti e li invia ad Azure OpenAI. Man mano che i blocchi di flusso vengono restituiti da Azure OpenAI, vengono inviati al client.

Se il problema non viene risolto, registralo nei Problemi del repository.

Passaggi successivi

Se il problema non viene risolto, registralo nei Problemi del repository.

Se il problema non viene risolto, registralo nei Problemi del repository.