Liaison d’entrée d’incorporation Azure OpenAI pour Azure Functions

Important

L’extension Azure OpenAI pour Azure Functions est actuellement en préversion.

La liaison d’entrée d’incorporation Azure OpenAI vous permet de générer des incorporations pour les entrées. La liaison peut générer des incorporations à partir de fichiers ou d’entrées de texte brut.

Pour plus d’informations sur l’installation et la configuration de l’extension Azure OpenAI, consultez Extensions Azure OpenAI pour Azure Functions. Pour en savoir plus sur les incorporations dans Azure OpenAI Service, consultez Comprendre les incorporations dans Azure OpenAI Service.

Remarque

Les références et les exemples sont fournis uniquement pour le modèle Node.js v4.

Remarque

Les références et exemples sont fournis uniquement pour le modèle Python v2.

Remarque

Bien que les deux modèles de processus C# soient pris en charge, seuls les exemples de modèles worker isolés sont fournis.

Exemple

Le support Go n’est pas disponible pour ce liaison pour le moment.

Cet exemple montre comment générer des incorporations pour une chaîne de texte brut.

internal class EmbeddingsRequest
{
    [JsonPropertyName("rawText")]
    public string? RawText { get; set; }

    [JsonPropertyName("filePath")]
    public string? FilePath { get; set; }

    [JsonPropertyName("url")]
    public string? Url { get; set; }
}

/// <summary>
/// Example showing how to use the <see cref="EmbeddingsAttribute"/> input binding to generate embeddings 
/// for a raw text string.
/// </summary>
[Function(nameof(GenerateEmbeddings_Http_RequestAsync))]
public async Task GenerateEmbeddings_Http_RequestAsync(
    [HttpTrigger(AuthorizationLevel.Function, "post", Route = "embeddings")] HttpRequestData req,
    [EmbeddingsInput("{rawText}", InputType.RawText, EmbeddingsModel = "%EMBEDDING_MODEL_DEPLOYMENT_NAME%", AIConnectionName = "AzureOpenAI")] EmbeddingsContext embeddings)
{
    using StreamReader reader = new(req.Body);
    string request = await reader.ReadToEndAsync();

    EmbeddingsRequest? requestBody = JsonSerializer.Deserialize<EmbeddingsRequest>(request);

    this.logger.LogInformation(
        "Received {count} embedding(s) for input text containing {length} characters.",
        embeddings.Count,
        requestBody?.RawText?.Length);

    // TODO: Store the embeddings into a database or other storage.
}

Cet exemple montre comment récupérer des incorporations stockées dans un fichier spécifié accessible à la fonction.

[Function(nameof(GetEmbeddings_Http_FilePath))]
public async Task GetEmbeddings_Http_FilePath(
    [HttpTrigger(AuthorizationLevel.Function, "post", Route = "embeddings-from-file")] HttpRequestData req,
    [EmbeddingsInput("{filePath}", InputType.FilePath, MaxChunkLength = 512, EmbeddingsModel = "%EMBEDDING_MODEL_DEPLOYMENT_NAME%", AIConnectionName = "AzureOpenAI")] EmbeddingsContext embeddings)
{
    using StreamReader reader = new(req.Body);
    string request = await reader.ReadToEndAsync();

    EmbeddingsRequest? requestBody = JsonSerializer.Deserialize<EmbeddingsRequest>(request);
    this.logger.LogInformation(
        "Received {count} embedding(s) for input file '{path}'.",
        embeddings.Count,
        requestBody?.FilePath);

    // TODO: Store the embeddings into a database or other storage.
}

Cet exemple montre comment générer des incorporations pour une chaîne de texte brut.

@FunctionName("GenerateEmbeddingsHttpRequest")
public HttpResponseMessage generateEmbeddingsHttpRequest(
        @HttpTrigger(
            name = "req", 
            methods = {HttpMethod.POST},
            authLevel = AuthorizationLevel.FUNCTION,
            route = "embeddings")
        HttpRequestMessage<EmbeddingsRequest> request,
        @EmbeddingsInput(name = "Embeddings", input = "{RawText}", inputType = InputType.RawText, embeddingsModel = "%EMBEDDING_MODEL_DEPLOYMENT_NAME%", aiConnectionName = "AzureOpenAI") String embeddingsContext,
        final ExecutionContext context) {

    if (request.getBody() == null) 
    {
        throw new IllegalArgumentException(
                "Invalid request body. Make sure that you pass in {\"rawText\": value } as the request body.");
    }

    JSONObject embeddingsContextJsonObject = new JSONObject(embeddingsContext);

    context.getLogger().info(String.format("Received %d embedding(s) for input text containing %s characters.",
            embeddingsContextJsonObject.get("count"),
            request.getBody().getRawText().length()));

    // TODO: Store the embeddings into a database or other storage.
    return request.createResponseBuilder(HttpStatus.ACCEPTED)
            .header("Content-Type", "application/json")
            .build();
}

Cet exemple montre comment récupérer des incorporations stockées dans un fichier spécifié accessible à la fonction.

@FunctionName("GenerateEmbeddingsHttpFilePath")
public HttpResponseMessage generateEmbeddingsHttpFilePath(
    @HttpTrigger(
        name = "req", 
        methods = {HttpMethod.POST},
        authLevel = AuthorizationLevel.FUNCTION,
        route = "embeddings-from-file")
    HttpRequestMessage<EmbeddingsRequest> request,
    @EmbeddingsInput(name = "Embeddings", input = "{FilePath}", inputType = InputType.FilePath, maxChunkLength = 512, embeddingsModel = "%EMBEDDING_MODEL_DEPLOYMENT_NAME%", aiConnectionName = "AzureOpenAI") String embeddingsContext,
    final ExecutionContext context) {

    if (request.getBody() == null) 
    {
        throw new IllegalArgumentException(
                "Invalid request body. Make sure that you pass in {\"filePath\": value } as the request body.");
    }

    JSONObject embeddingsContextJsonObject = new JSONObject(embeddingsContext);

    context.getLogger().info(String.format("Received %d embedding(s) for input file %s.",
            embeddingsContextJsonObject.get("count"),
            request.getBody().getFilePath()));

    // TODO: Store the embeddings into a database or other storage.
    return request.createResponseBuilder(HttpStatus.ACCEPTED)
            .header("Content-Type", "application/json")
            .build();
}

Cet exemple montre comment générer des incorporations pour une chaîne de texte brut.

const embeddingsHttpInput = input.generic({
    input: '{rawText}',
    inputType: 'RawText',
    type: 'embeddings',
    embeddingsModel: '%EMBEDDING_MODEL_DEPLOYMENT_NAME%',
    aiConnectionName: 'AzureOpenAI',
})

app.http('generateEmbeddings', {
    methods: ['POST'],
    route: 'embeddings',
    authLevel: 'function',
    extraInputs: [embeddingsHttpInput],
    handler: async (request, context) => {
        let requestBody = await request.json();
        let response = context.extraInputs.get(embeddingsHttpInput);

        context.log(
            `Received ${response.count} embedding(s) for input text containing ${requestBody.rawText?.length ?? 0} characters.`
        );
        
        // TODO: Store the embeddings into a database or other storage.

        return {status: 202}
    }

interface EmbeddingsHttpRequest {
    rawText?: string;
}

const embeddingsHttpInput = input.generic({
    input: '{rawText}',
    inputType: 'RawText',
    type: 'embeddings',
    embeddingsModel: '%EMBEDDING_MODEL_DEPLOYMENT_NAME%',
    aiConnectionName: 'AzureOpenAI',
})

app.http('generateEmbeddings', {
    methods: ['POST'],
    route: 'embeddings',
    authLevel: 'function',
    extraInputs: [embeddingsHttpInput],
    handler: async (request, context) => {
        let requestBody: EmbeddingsHttpRequest = await request.json();
        let response: any = context.extraInputs.get(embeddingsHttpInput);

        context.log(
            `Received ${response.count} embedding(s) for input text containing ${requestBody.rawText?.length ?? 0} characters.`
        );
        
        // TODO: Store the embeddings into a database or other storage.

        return {status: 202}
    }

Cet exemple montre comment générer des incorporations pour une chaîne de texte brut.


const embeddingsFilePathInput = input.generic({
    input: '{filePath}',
    inputType: 'FilePath',
    type: 'embeddings',
    maxChunkLength: 512,
    embeddingsModel: '%EMBEDDING_MODEL_DEPLOYMENT_NAME%',
    aiConnectionName: 'AzureOpenAI',
})

app.http('getEmbeddingsFilePath', {
    methods: ['POST'],
    route: 'embeddings-from-file',
    authLevel: 'function',
    extraInputs: [embeddingsFilePathInput],
    handler: async (request, context) => {
        let requestBody = await request.json();
        let response = context.extraInputs.get(embeddingsFilePathInput);

        context.log(
            `Received ${response.count} embedding(s) for input file ${requestBody.filePath}.`
        );
        
        // TODO: Store the embeddings into a database or other storage.

        return {status: 202}


interface EmbeddingsFilePath {
    filePath?: string;
}

const embeddingsFilePathInput = input.generic({
    input: '{filePath}',
    inputType: 'FilePath',
    type: 'embeddings',
    maxChunkLength: 512,
    embeddingsModel: '%EMBEDDING_MODEL_DEPLOYMENT_NAME%',
    aiConnectionName: 'AzureOpenAI',
})

app.http('getEmbeddingsFilePath', {
    methods: ['POST'],
    route: 'embeddings-from-file',
    authLevel: 'function',
    extraInputs: [embeddingsFilePathInput],
    handler: async (request, context) => {
        let requestBody: EmbeddingsFilePath = await request.json();
        let response: any = context.extraInputs.get(embeddingsFilePathInput);

        context.log(
            `Received ${response.count} embedding(s) for input file ${requestBody.filePath}.`
        );
        
        // TODO: Store the embeddings into a database or other storage.

        return {status: 202}

Cet exemple montre comment générer des incorporations pour une chaîne de texte brut.

Voici le fichier function.json pour générer les incorporations :

{
  "bindings": [
    {
      "authLevel": "function",
      "type": "httpTrigger",
      "direction": "in",
      "name": "Request",
      "route": "embeddings",
      "methods": [
        "post"
      ]
    },
    {
      "type": "http",
      "direction": "out",
      "name": "Response"
    },
    {
      "name": "Embeddings",
      "type": "embeddings",
      "direction": "in",
      "inputType": "RawText",
      "input": "{rawText}",
      "embeddingsModel": "%EMBEDDING_MODEL_DEPLOYMENT_NAME%",
      "aiConnectionName": "AzureOpenAI"
    }
  ]
}

Pour plus d’informations sur les propriétés du fichier function.json, consultez la section Configuration.

using namespace System.Net

param($Request, $TriggerMetadata, $Embeddings)

$input = $Request.Body.RawText

Write-Host "Received $($Embeddings.Count) embedding(s) for input text containing $($input.Length) characters."

Push-OutputBinding -Name Response -Value ([HttpResponseContext]@{
        StatusCode = [HttpStatusCode]::Accepted
})

Cet exemple montre comment générer des incorporations pour une chaîne de texte brut.

@app.function_name("GenerateEmbeddingsHttpRequest")
@app.route(route="embeddings", methods=["POST"])
@app.embeddings_input(
    arg_name="embeddings",
    input="{rawText}",
    input_type="rawText",
    embeddings_model="%EMBEDDING_MODEL_DEPLOYMENT_NAME%",
    ai_connection_name="AzureOpenAI",
)
def generate_embeddings_http_request(
    req: func.HttpRequest, embeddings: str
) -> func.HttpResponse:
    user_message = req.get_json()
    embeddings_json = json.loads(embeddings)
    embeddings_request = {"raw_text": user_message.get("rawText")}
    logging.info(
        f'Received {embeddings_json.get("count")} embedding(s) for input text '
        f'containing {len(embeddings_request.get("raw_text"))} characters.'
    )
    # TODO: Store the embeddings into a database or other storage.

Attributs

Appliquez l’attribut EmbeddingsInput pour définir une liaison d’entrée d’incorporation, qui prend en charge ces paramètres :

Paramètre Descriptif
Entrée La chaîne d’entrée pour laquelle générer des incorporations.
AIConnectionName Facultatif. Obtient ou définit le nom de la section de configuration pour les paramètres de connectivité du service IA. Pour Azure OpenAI : s’il est spécifié, recherche les valeurs « Point de terminaison » et « Clé » dans cette section de configuration. S’il n’existe pas ou si la section n’existe pas, revient aux variables d’environnement : AZURE_OPENAI_ENDPOINT et AZURE_OPENAI_KEY. Pour l’authentification d’identité managée affectée par l’utilisateur, cette propriété est requise. Pour le service OpenAI (non-Azure), définissez la variable d’environnement OPENAI_API_KEY.
EmbeddingsModel Facultatif. L’ID du modèle à utiliser, par défaut text-embedding-ada-002. Vous ne devez pas modifier le modèle d’une base de données existante. Pour plus d’informations, consultez Utilisation.
MaxChunkLength Facultatif. Le nombre maximal de caractères utilisés pour segmenter l’entrée. Pour plus d’informations, consultez Utilisation.
MaxOverlap Facultatif. Obtient ou définit le nombre maximal de caractères à chevaucher entre les blocs.
InputType Facultatif. Obtient le type de l’entrée.

Commentaires

L’annotation EmbeddingsInput vous permet de définir une liaison d’entrée d’incorporation, qui prend en charge ces paramètres :

Élément Descriptif
nom Obtient ou définit le nom de la liaison d’entrée.
d’entrée La chaîne d’entrée pour laquelle générer des incorporations.
aiConnectionName Facultatif. Obtient ou définit le nom de la section de configuration pour les paramètres de connectivité du service IA. Pour Azure OpenAI : s’il est spécifié, recherche les valeurs « Point de terminaison » et « Clé » dans cette section de configuration. S’il n’existe pas ou si la section n’existe pas, revient aux variables d’environnement : AZURE_OPENAI_ENDPOINT et AZURE_OPENAI_KEY. Pour l’authentification d’identité managée affectée par l’utilisateur, cette propriété est requise. Pour le service OpenAI (non-Azure), définissez la variable d’environnement OPENAI_API_KEY.
embeddingsModel Facultatif. L’ID du modèle à utiliser, par défaut text-embedding-ada-002. Vous ne devez pas modifier le modèle d’une base de données existante. Pour plus d’informations, consultez Utilisation.
maxChunkLength Facultatif. Le nombre maximal de caractères utilisés pour segmenter l’entrée. Pour plus d’informations, consultez Utilisation.
maxOverlap Facultatif. Obtient ou définit le nombre maximal de caractères à chevaucher entre les blocs.
inputType Facultatif. Obtient le type de l’entrée.

Décorateurs

Pendant la préversion, définissez la liaison d’entrée en tant que liaison generic_input_binding de type embeddings, qui prend en charge ces paramètres : le décorateur embeddings prend en charge ces paramètres :

Paramètre Descriptif
arg_name Le nom de la variable qui représente le paramètre de liaison.
d’entrée La chaîne d’entrée pour laquelle générer des incorporations.
ai_connection_name Facultatif. Obtient ou définit le nom de la section de configuration pour les paramètres de connectivité du service IA. Pour Azure OpenAI : s’il est spécifié, recherche les valeurs « Point de terminaison » et « Clé » dans cette section de configuration. S’il n’existe pas ou si la section n’existe pas, revient aux variables d’environnement : AZURE_OPENAI_ENDPOINT et AZURE_OPENAI_KEY. Pour l’authentification d’identité managée affectée par l’utilisateur, cette propriété est requise. Pour le service OpenAI (non-Azure), définissez la variable d’environnement OPENAI_API_KEY.
embeddings_model Facultatif. L’ID du modèle à utiliser, par défaut text-embedding-ada-002. Vous ne devez pas modifier le modèle d’une base de données existante. Pour plus d’informations, consultez Utilisation.
maxChunkLength Facultatif. Le nombre maximal de caractères utilisés pour segmenter l’entrée. Pour plus d’informations, consultez Utilisation.
max_overlap Facultatif. Obtient ou définit le nombre maximal de caractères à chevaucher entre les blocs.
input_type Obtient le type de l’entrée.

Paramétrage

La liaison prend en charge ces propriétés de configuration que vous définissez dans le fichier function.json.

Propriété Descriptif
type Doit être EmbeddingsInput.
direction Doit être in.
nom Le nom de la liaison d’entrée.
d’entrée La chaîne d’entrée pour laquelle générer des incorporations.
aiConnectionName Facultatif. Obtient ou définit le nom de la section de configuration pour les paramètres de connectivité du service IA. Pour Azure OpenAI : s’il est spécifié, recherche les valeurs « Point de terminaison » et « Clé » dans cette section de configuration. S’il n’existe pas ou si la section n’existe pas, revient aux variables d’environnement : AZURE_OPENAI_ENDPOINT et AZURE_OPENAI_KEY. Pour l’authentification d’identité managée affectée par l’utilisateur, cette propriété est requise. Pour le service OpenAI (non-Azure), définissez la variable d’environnement OPENAI_API_KEY.
embeddingsModel Facultatif. L’ID du modèle à utiliser, par défaut text-embedding-ada-002. Vous ne devez pas modifier le modèle d’une base de données existante. Pour plus d’informations, consultez Utilisation.
maxChunkLength Facultatif. Le nombre maximal de caractères utilisés pour segmenter l’entrée. Pour plus d’informations, consultez Utilisation.
maxOverlap Facultatif. Obtient ou définit le nombre maximal de caractères à chevaucher entre les blocs.
inputType Facultatif. Obtient le type de l’entrée.

Paramétrage

La liaison prend en charge ces propriétés, qui sont définies dans votre code :

Propriété Descriptif
d’entrée La chaîne d’entrée pour laquelle générer des incorporations.
aiConnectionName Facultatif. Obtient ou définit le nom de la section de configuration pour les paramètres de connectivité du service IA. Pour Azure OpenAI : s’il est spécifié, recherche les valeurs « Point de terminaison » et « Clé » dans cette section de configuration. S’il n’existe pas ou si la section n’existe pas, revient aux variables d’environnement : AZURE_OPENAI_ENDPOINT et AZURE_OPENAI_KEY. Pour l’authentification d’identité managée affectée par l’utilisateur, cette propriété est requise. Pour le service OpenAI (non-Azure), définissez la variable d’environnement OPENAI_API_KEY.
embeddingsModel Facultatif. L’ID du modèle à utiliser, par défaut text-embedding-ada-002. Vous ne devez pas modifier le modèle d’une base de données existante. Pour plus d’informations, consultez Utilisation.
maxChunkLength Facultatif. Le nombre maximal de caractères utilisés pour segmenter l’entrée. Pour plus d’informations, consultez Utilisation.
maxOverlap Facultatif. Obtient ou définit le nombre maximal de caractères à chevaucher entre les blocs.
inputType Facultatif. Obtient le type de l’entrée.

Pour obtenir des exemples complets, consultez la section Exemple.

Utilisation

La modification du model des incorporations par défaut modifie la façon dont les incorporations sont stockées dans la base de données vectorielle. La modification du modèle par défaut peut entraîner un comportement incorrect des recherches lorsqu’elles ne correspondent pas au reste des données précédemment ingérées dans la base de données vectorielle. Le modèle par défaut pour les incorporations est text-embedding-ada-002.

Lors du calcul de la longueur maximale des caractères pour les blocs d’entrée, considérez que le nombre maximum de jetons d’entrée autorisés pour les modèles d’incorporation d’entrée de deuxième génération comme text-embedding-ada-002 est de 8191. Un seul jeton est d’environ quatre caractères de longueur (en anglais), qui se traduit par environ 32 000 caractères d’entrée (en anglais) qu’un bloc unique peut contenir.

Connections

Pour utiliser l’extension de liaison Azure OpenAI, vous devez spécifier une connexion à une définition de modèle OpenAI. Configurez la connexion du modèle OpenAI dans vos liaisons en utilisant l’une de ces approches :

  • Utilisez la AIConnectionName propriété de liaison (préférée pour Azure OpenAI).
  • Définissez AZURE_OPENAI_ENDPOINT et AZURE_OPENAI_KEY dans les paramètres de l’application (pour Azure OpenAI).
  • Réglez uniquement Open_API_Key dans les paramètres de l’application (pour https://api.openai.com).

La façon dont vous définissez la connexion dépend à la fois de l’API du modèle et de la méthode d’authentification, comme indiqué par le tableau suivant :

API d’authentification/modèle Azure OpenAI OpenAI (https://api.openai.com)
Connexion d’identité gérée AIConnectionName Non pris en charge
Référence Key Vault AZURE_OPENAI_ENDPOINT
AZURE_OPENAI_KEY		 Open_API_Key
Référence de configuration de l’application AZURE_OPENAI_ENDPOINT
AZURE_OPENAI_KEY		 Open_API_Key
Secret partagé AZURE_OPENAI_ENDPOINT
AZURE_OPENAI_KEY		 Open_API_Key

Utilisez des connexions basées sur l’identité et la AIConnectionName propriété.

Lorsque vous utilisez AIConnectionName, la valeur de ce réglage de propriété dépend du type de connexion :

  • Connexion d’identité gérée : Cette AIConnectionName propriété est <CONNECTION_NAME_PREFIX> partagée par un groupe de paramètres qui définissent ensemble une connexion basée sur l’identité avec Azure OpenAI. Pour plus d’informations, voir Définir les connexions identités.
  • Référence Key Vault : Le AIConnectionName paramètre de propriété renvoie une référence Azure Key Vault à l’emplacement où la clé API est centralisée. Pour plus d’informations, voir Définir les connexions Key Vault.
  • Référence App Configuration : Le AIConnectionName paramètre de propriété renvoie une référence Azure App Configuration qui renvoie une clé API ou une référence Key Vault. Pour plus d’informations, consultez Azure App Configuration dans l’article sur les connexions.
  • Clé API : Le AIConnectionName paramètre de propriété se résout aux paramètres de l’application contenant directement le point de terminaison et la clé. Comme les clés partagées peuvent être compromises, utilisez des connexions d’identité gérées lorsque cela est possible. Pour plus d’informations, voir Définir les connexions.

Pour en savoir plus sur les connexions de liaisons, voir Gérer les connexions dans Azure Functions.

Les liaisons OpenAI incluent une AIConnectionName propriété que vous pouvez utiliser pour spécifier le <ConnectionNamePrefix> groupe de paramètres d’application qui définissent la connexion à Azure OpenAI :

Nom de la configuration Descriptif
<CONNECTION_NAME_PREFIX>__endpoint Définit le point de terminaison URI du service Azure OpenAI. Ce paramètre est toujours requis.
<CONNECTION_NAME_PREFIX>__clientId Définit l’identité affectée par l’utilisateur spécifique à utiliser lors de l’obtention d’un jeton d’accès. Exige que <CONNECTION_NAME_PREFIX>__credential soit défini sur managedidentity. La propriété accepte un ID client correspondant à une identité attribuée par l’utilisateur affectée à l’application. Il incorrect de spécifier à la fois un ID de la ressource et un ID client. Si vous ne spécifiez pas cette propriété, l’identité attribuée par le système est utilisée. Cette propriété est utilisée différemment dans des scénarios de développement local lorsque credential ne doit pas être défini.
<CONNECTION_NAME_PREFIX>__credential Définit la façon dont un jeton access est obtenu pour la connexion. Utiliser managedidentity pour l’authentification d’identité managée. Cette valeur n’est valide que lorsqu’une identité managée est disponible dans l’environnement d’hébergement.
<CONNECTION_NAME_PREFIX>__managedIdentityResourceId Lorsque credential est défini à managedidentity, définissez cette propriété pour spécifier l’identifiant de ressource à utiliser lors de l’obtention d’un jeton. La propriété accepte un identifiant de ressource correspondant à l’ID de la ressource de l’identité managée définie par l’utilisateur. Il n’est pas correct de spécifier à la fois un ID de la ressource et un ID client. Si vous ne spécifiez ni l’un ni l’autre, l’identité attribuée par le système est utilisée. Cette propriété est utilisée différemment dans des scénarios de développement local lorsque credential ne doit pas être défini.
<CONNECTION_NAME_PREFIX>__key Définit la clé secrète partagée nécessaire pour accéder au point de terminaison du service OpenAI Azure en utilisant une authentification basée sur une clé. En guise de bonne pratique en matière de sécurité, utilisez toujours Microsoft Entra ID avec des identités gérées pour l’authentification.

Considérez ces paramètres de connexion d’identité gérée lorsque vous définissez la AIConnectionName propriété à myAzureOpenAI:

  • myAzureOpenAI__endpoint=https://contoso.openai.azure.com/
  • myAzureOpenAI__credential=managedidentity
  • myAzureOpenAI__clientId=aaaaaaaa-bbbb-cccc-1111-222222222222

À l’exécution, l’hôte interprète ces paramètres comme un seul myAzureOpenAI paramètre :

"myAzureOpenAI":
{
    "endpoint": "https://contoso.openai.azure.com/",
    "credential": "managedidentity",
    "clientId": "aaaaaaaa-bbbb-cccc-1111-222222222222"
}

Lorsque vous utilisez des identités gérées, assurez-vous d’ajouter votre identité au rôle d’utilisateur OpenAI des services cognitifs .

Lors de l’exécution locale, ajoutez ces paramètres au fichierlocal.settings.json projet. Pour plus d’informations, consultez Développement local avec des connexions basées sur des identités.

Pour plus d’informations, consultez Utiliser des paramètres d’application.

Contenu connexe

  • Last updated on