Bien démarrer avec le bloc de construction de sécurité Azure OpenAI

• Microsoft AI Chat Protocol fournit des contrats d’API standardisés pour les solutions et les langages d’IA. L’application de chat est conforme au Microsoft AI Chat Protocol, ce qui permet à l’application d’évaluation de fonctionner avec toute application de chat conforme au protocole.
• Quart Python qui utilise le openai package pour générer des réponses aux messages utilisateur.
• Frontend HTML/JavaScript de base qui diffuse des réponses du back-end à l’aide de lignes JSON sur un readableStream.

• Application web Blazor qui utilise le package NuGet Azure.AI.OpenAI pour générer des réponses aux messages utilisateur.

• Application web TypeScript qui utilise le package openai npm pour générer des réponses aux messages utilisateur.

En savoir plus sur les coûts dans l’exemple de dépôt.

En savoir plus sur les coûts dans l’exemple de dépôt.

En savoir plus sur les coûts dans l’exemple de dépôt.

Exploration de l’exemple de code

Bien qu’OpenAI et Azure OpenAI Service s’appuient sur une bibliothèque de client Python commune, de petites modifications de code sont nécessaires lors de l’utilisation de points de terminaison Azure OpenAI. Voyons comment cet exemple configure l’authentification sans clé avec l’ID Microsoft Entra et communique avec Azure OpenAI.

Configurer l’authentification avec une identité managée

Dans cet exemple, le fichier commence par la configuration de l’authentification src\quartapp\chat.py sans clé.

L’extrait de code suivant utilise le module azure.identity.aio pour créer un flux d’authentification Microsoft Entra asynchrone.

L’extrait de code suivant utilise la AZURE_CLIENT_IDazd variable d’environnement pour créer une instance ManagedIdentityCredential capable de s’authentifier via une identité managée affectée par l’utilisateur.

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

L’extrait de code suivant utilise AZURE_TENANT_IDazd la variable d’environnement de ressource pour créer une instance AzureDeveloperCliCredential capable d’être authentifiée avec le locataire Microsoft Entra actuel.

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

La bibliothèque cliente Azure Identity fournit des informations d’identification : des classes publiques qui implémentent le protocole TokenCredential de la bibliothèque Azure Core. Les informations d’identification représentent un flux d’authentification distinct pour l’acquisition d’un jeton d’accès à partir de l’ID Microsoft Entra. Ces informations d’identification peuvent être chaînées pour former une séquence ordonnée de mécanismes d’authentification à essayer.

L’extrait de code suivant crée un ChainedTokenCredential code à l’aide d’un et d’un ManagedIdentityCredentialAzureDeveloperCliCredential:

• Il ManagedIdentityCredential est utilisé pour Azure Functions et Azure App Service. Une identité managée affectée par l’utilisateur est prise en charge par le passage à client_idManagedIdentityCredential.
• Il AzureDeveloperCliCredential est utilisé pour le développement local. Il a été défini précédemment en fonction du locataire Microsoft Entra à utiliser.

azure_credential = ChainedTokenCredential(
    user_assigned_managed_identity_credential,
    azure_dev_cli_credential
)

L’extrait de code suivant obtient le fournisseur de jetons Azure OpenAI en fonction des informations d’identification Azure sélectionnées. Cette valeur est obtenue en appelant le azure.identity.aio.get_bearer_token_provider avec deux arguments :

• azure_credential: instance ChainedTokenCredential créée précédemment pour authentifier la requête.

• https://cognitiveservices.azure.com/.default: étendues de jeton du porteur requises. Dans ce cas, le point de terminaison Azure Cognitive Services .

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

Les lignes suivantes vérifient les variables d’environnement requises AZURE_OPENAI_ENDPOINT et AZURE_OPENAI_CHATGPT_DEPLOYMENTazd d’environnement de ressources, qui sont provisionnées pendant azd le déploiement de l’application. Une erreur est levée si une valeur n’est pas présente.

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

Cet extrait de code initialise le client Azure OpenAI, en définissant les api_versionparamètres , azure_endpointet 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 ligne suivante définit le nom de déploiement du modèle Azure OpenAI à utiliser dans les appels d’API :

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

Une fois cette fonction terminée, le client est correctement configuré et prêt à interagir avec les services Azure OpenAI.

Flux de réponse à l’aide du client et du modèle OpenAI

Gère response_stream l’appel de saisie semi-automatique de conversation dans l’itinéraire. L’extrait de code suivant montre comment openai_client et model sont utilisés.

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

Explorer l’exemple de code

Les applications .NET s’appuient sur la bibliothèque cliente Azure.AI.OpenAI pour communiquer avec les services Azure OpenAI , ce qui dépend de la bibliothèque OpenAI . L’exemple d’application configure l’authentification sans clé à l’aide de l’ID Microsoft Entra pour communiquer avec Azure OpenAI.

Configurer l’authentification et l’inscription de service

Dans cet exemple, l’authentification sans clé est configurée dans le program.cs fichier. L’extrait de code suivant utilise la AZURE_CLIENT_ID variable d’environnement définie pour azd créer une instance ManagedIdentityCredential capable d’s’authentifier via une identité managée affectée par l’utilisateur.

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

L’extrait de code suivant utilise la AZURE_TENANT_ID variable d’environnement définie par azd pour créer une instance AzureDeveloperCliCredential capable d’s’authentifier localement à l’aide du compte connecté à azd.

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

La bibliothèque cliente Azure Identity fournit des classes d’informations d’identification qui implémentent le protocole TokenCredential de la bibliothèque Azure Core. Les informations d’identification représentent un flux d’authentification distinct pour l’acquisition d’un jeton d’accès à partir de l’ID Microsoft Entra. Ces informations d’identification peuvent être chaînées à l’aide ChainedTokenCredential d’une séquence ordonnée de mécanismes d’authentification à essayer.

L’extrait de code suivant inscrit l’injection de dépendances et crée un code à l’aide AzureOpenAIClient d’un et d’un ChainedTokenCredentialManagedIdentityCredential:AzureDeveloperCliCredential

• Il ManagedIdentityCredential est utilisé pour Azure Functions et Azure App Service. Une identité managée affectée par l’utilisateur est prise en charge à l’aide de celle AZURE_CLIENT_IDManagedIdentityCredentialqui a été fournie au .
• Il AzureDeveloperCliCredential est utilisé pour le développement local. Il a été défini précédemment en fonction du locataire Microsoft Entra à utiliser.

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

Obtenir des achèvements de conversation à l’aide du client Azure OpenAI

L’application web Blazor injecte l’inscription AzureOpenAIClient en haut du Home.Razor composant :

@inject AzureOpenAIClient azureOpenAIClient

Lorsque l’utilisateur envoie le formulaire, il AzureOpenAIClient envoie son invite au modèle OpenAI pour générer une saisie semi-automatique :

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

Explorer l’exemple de code

Bien que OpenAI et Azure OpenAI Service s’appuient sur un openai (bibliothèque de client JavaScript commune), de petites modifications de code sont nécessaires lors de l’utilisation de points de terminaison Azure OpenAI. Voyons comment cet exemple configure l’authentification sans clé avec l’ID Microsoft Entra et communique avec Azure OpenAI.

Authentification sans clé pour chaque environnement

La bibliothèque cliente Azure Identity fournit des classes d’informations d’identification qui implémentent le protocole TokenCredential de la bibliothèque Azure Core. Les informations d’identification représentent un flux d’authentification distinct pour l’acquisition d’un jeton d’accès à partir de l’ID Microsoft Entra. Ces informations d’identification peuvent être chaînées à l’aide ChainedTokenCredential d’une séquence ordonnée de mécanismes d’authentification à essayer. Cela vous permet de déployer le même code dans les environnements de production et de développement local.

Configurer l’authentification avec une identité managée

Dans cet exemple, plusieurs ./src/azure-authentication.ts fonctions permettent de fournir une authentification sans clé à Azure OpenAI.

La première fonction, retourne getChainedCredential()les premières informations d’identification Azure valides trouvées dans la chaîne.

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 est tenté en premier. Il est configuré avec la variable d’environnement AZURE_CLIENT_ID dans le runtime de production et peut s’authentifier via l’identité managée affectée par l’utilisateur.
• AzureDeveloperCliCredential est tenté deuxième. Il est configuré lorsqu’un développement se connecte avec Azure CLI az login.

Obtenir le jeton du porteur pour OpenAI

La deuxième fonction est ./src/azure-authentication.tsgetTokenProvider(), qui retourne un rappel qui fournit un jeton du porteur délimité au point de terminaison Azure Cognitive Services .

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

L’extrait de code précédent utilise getBearerTokenProvider pour prendre les informations d’identification et l’étendue, puis retourne un rappel qui fournit un jeton du porteur.

Créer un client Azure OpenAI authentifié

La troisième fonction est ./src/azure-authentication.tsgetOpenAiClient(), qui retourne le client Azure OpenAI.

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

Ce code prend les options, y compris le jeton correctement délimité, et crée le AzureOpenAI client

Diffuser en continu une réponse de conversation avec Azure OpenAI

Utilisez le gestionnaire de routage Fastify suivant pour ./src/openai-chat-api.ts envoyer un message à Azure OpenAI et diffuser en continu la réponse.

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 fonction obtient la conversation de conversation, y compris les messages précédents, et les envoie à Azure OpenAI. À mesure que les blocs de flux sont retournés à partir d’Azure OpenAI, ils sont envoyés au client.

Si votre problème n’est pas résolu, consignez votre problème dans les Problèmes du référentiel.

Étapes suivantes

Si votre problème n’est pas résolu, consignez votre problème dans les Problèmes du référentiel.

Si votre problème n’est pas résolu, consignez votre problème dans les Problèmes du référentiel.