Démarrage rapide : commencer à utiliser GPT-35-Turbo et GPT-4 avec Azure OpenAI Service

Prérequis

• Un abonnement Azure : créez-en un gratuitement.
• Une ressource Azure OpenAI Service avec les modèles gpt-4o ou gpt-4o-mini déployés. Nous vous recommandons d’utiliser des types de déploiement de modèle standard ou standard global pour l’exploration initiale. Pour plus d’informations sur le déploiement de modèle, consultez le guide de déploiement de ressources.

Connectez-vous à Azure OpenAI Studio

Accédez à Azure OpenAI Studio sur https://oai.azure.com/ et connectez-vous avec les informations d’identification qui ont accès à votre ressource Azure OpenAI. Pendant ou après le flux de travail de connexion, sélectionnez le répertoire approprié, l’abonnement Azure et la ressource Azure OpenAI.

Dans la page d’arrivée Azure OpenAI Studio, sélectionnez le terrain de jeu Chat.

Terrain de jeu

Commencez à explorer les fonctionnalités OpenAI avec une approche sans code via le terrain de jeu Chat de Azure OpenAI Studio. À partir de cette page, vous pouvez rapidement itérer et expérimenter les fonctionnalités.

Programme d’installation

Pour commencer, vous pouvez utiliser le menu déroulant Exemples d’invites pour sélectionner quelques exemples de Messages système préchargés.

Les messages système fournissent au modèle des instructions sur son comportement et sur tout contexte qu’il doit référencer en générant une réponse. Vous pouvez décrire la personnalité de l’assistant, lui dire ce qu’il doit et ne doit pas répondre, et lui indiquer comment formater les réponses.

Lors de l’utilisation du terrain de jeu Chat, vous pouvez à tout moment sélectionner Afficher le code pour voir les exemples de code Python, curl et json préremplis en fonction de votre session de conversation actuelle et des sélections de paramètres. Vous pouvez ensuite prendre ce code et écrire une application pour effectuer la même tâche que celle que vous effectuez actuellement dans le terrain de jeu.

Session de conversation

En appuyant sur le bouton Entrée ou l’icône de flèche vers la droite, vous envoyez le texte communiqué à l’API de saisie semi-automatique de conversation et les résultats sont renvoyés vers la zone de texte.

Sélectionnez le bouton Effacer la conversation pour supprimer l’historique actuel des conversations.

Paramètres importants

Afficher le code

Une fois que vous avez testé la conversation avec le modèle, sélectionnez le bouton</> Afficher le code. L’ensemble du code derrière toute votre conversation jusqu’à présent sera ainsi affiché :

Comprendre la structure d’invite

Si vous examinez l’exemple obtenu après avoir cliqué sur Afficher le code, vous remarquerez que la conversation est divisée en trois rôles distincts system, user, assistant. Chaque fois que vous envoyez un message au modèle, l’historique des conversations jusqu’à ce point est à nouveau envoyé. Lorsque vous utilisez l’API de saisie semi-automatique de conversation, le modèle n’a pas de mémoire réelle de ce que vous lui avez envoyé par le passé. Fournissez donc l’historique des conversations à titre de contexte pour permettre au modèle de répondre correctement.

Le Guide pratique sur les saisies semi-automatiques de conversation fournit une introduction approfondie sur la nouvelle structure d’invite et explique comment utiliser efficacement les modèles de saisie semi-automatique de conversation.

Déployer votre modèle

Une fois satisfait de votre expérience dans Azure OpenAI Studio, vous pouvez déployer une application web directement à partir de Studio en sélectionnant le bouton Déployer sur.

Cela vous donne la possibilité de déployer sur une application web autonome ou un copilote dans Copilot Studio (préversion) si vous utilisez vos propres données sur le modèle.

Si vous choisissez par exemple de déployer une application web :

La première fois que vous déployez une application web, vous devez sélectionner Créer une application web. Choisissez un nom pour l’application, qui fera partie de l’URL de l’application. Par exemple : https://<appname>.azurewebsites.net.

Sélectionnez votre abonnement, votre groupe de ressources, votre emplacement et votre plan tarifaire pour l’application publiée. Pour mettre à jour une application existante, sélectionnez Publier sur une application web existante, puis choisissez le nom de votre application précédente dans le menu déroulant.

Si vous choisissez de déployer une application web, consultez les Points importants à prendre en compte pour son utilisation.

Nettoyer les ressources

Une fois vos tests du terrain de jeu Conversation terminés, vous pouvez supprimer la ressource ou le groupe de ressources si vous souhaitez nettoyer et supprimer une ressource Azure OpenAI. La suppression du groupe de ressources efface également les autres ressources qui y sont associées.

• Azure portal
• Azure CLI

Étapes suivantes

• En savoir plus sur l’utilisation du nouveau modèle gpt-35-turbo avec le Guide pratique de GPT-35-Turbo et GPT-4.
• Pour plus d’exemples, consultez le référentiel GitHub d’échantillons Azure OpenAI

Code source | Package (NuGet) | Exemples| Modèle de conversation d’entreprise de la génération augmentée de récupération (RAG) |

Prérequis

• Un abonnement Azure - En créer un gratuitement
• Le SDK .NET 7
• Une ressource Azure OpenAI Service avec les modèles gpt-35-turbo ou gpt-4 déployés. Pour plus d’informations sur le déploiement de modèle, consultez le guide de déploiement de ressources.

Configurer

Créez une application .NET Core

Dans une fenêtre de console (par exemple cmd, PowerShell ou Bash), utilisez la commande dotnet new pour créer une application console avec le nom azure-openai-quickstart. Cette commande crée un projet « Hello World » simple avec un seul fichier source C# : Program.cs.

dotnet new console -n azure-openai-quickstart

Déplacez vos répertoires vers le dossier d’application nouvellement créé. Vous pouvez générer l’application avec :

dotnet build

La sortie de génération ne doit contenir aucun avertissement ni erreur.

...
Build succeeded.
 0 Warning(s)
 0 Error(s)
...

Installez la bibliothèque de client .NET OpenAI avec :

dotnet add package Azure.AI.OpenAI --prerelease

Récupérer la clé et le point de terminaison

Pour effectuer correctement un appel sur Azure OpenAI, vous avez besoin d’un point de terminaison et d’une clé.

Accédez à votre ressource sur le portail Azure. La section Point de terminaison et les clés se trouvent dans la section Gestion des ressources. Copiez votre point de terminaison et votre clé d’accès, car vous aurez besoin de l’authentification de vos appels d’API. Vous pouvez utiliser soit KEY1, soit KEY2. Avoir toujours deux clés vous permet de faire pivoter et de régénérer en toute sécurité les clés sans provoquer d’interruption de service.

Variables d'environnement

Créez et affectez des variables d’environnement persistantes pour votre clé et votre point de terminaison.

setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE" 
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE" 

[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_API_KEY', 'REPLACE_WITH_YOUR_KEY_VALUE_HERE', 'User')
[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_ENDPOINT', 'REPLACE_WITH_YOUR_ENDPOINT_HERE', 'User')

export AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE"
export AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE"

Créer un exemple d’application

À partir du répertoire du projet, ouvrez le fichier program.cs et remplacez le contenu par le code suivant :

Sans diffusion en continu de réponse

using Azure;
using Azure.AI.OpenAI;
using static System.Environment;

string endpoint = GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT");
string key = GetEnvironmentVariable("AZURE_OPENAI_API_KEY");

AzureOpenAIClient azureClient = new(
    new Uri(endpoint),
    new AzureKeyCredential(key));

// This must match the custom deployment name you chose for your model
ChatClient chatClient = azureClient.GetChatClient("gpt-35-turbo");

ChatCompletion completion = chatClient.CompleteChat(
    [
        new SystemChatMessage("You are a helpful assistant that talks like a pirate."),
        new UserChatMessage("Does Azure OpenAI support customer managed keys?"),
        new AssistantChatMessage("Yes, customer managed keys are supported by Azure OpenAI"),
        new UserChatMessage("Do other Azure AI services support this too?")
    ]);

Console.WriteLine($"{completion.Role}: {completion.Content[0].Text}");

dotnet run program.cs

Output

Assistant : Yes, many other Azure AI services also support customer managed keys, including Azure Cognitive Services, Azure Machine Learning, and Azure Databricks. By using customer managed keys, you can retain complete control over your encryption keys and provide an additional layer of security for your AI assets.

Cela attendra que le modèle ait généré l’intégralité de sa réponse avant d’imprimer les résultats. Par ailleurs, si vous souhaitez diffuser la réponse en continu de manière asynchrone et imprimer les résultats, vous pouvez remplacer le contenu de program.cs par le code de l’exemple suivant.

Diffusion asynchrone en continu

using Azure;
using Azure.AI.OpenAI;
using OpenAI.Chat;
using static System.Environment;

string endpoint = GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT");
string key = GetEnvironmentVariable("AZURE_OPENAI_API_KEY");

AzureOpenAIClient azureClient = new(
    new Uri(endpoint),
    new AzureKeyCredential(key));

// This must match the custom deployment name you chose for your model
ChatClient chatClient = azureClient.GetChatClient("gpt-35-turbo");

var chatUpdates = chatClient.CompleteChatStreamingAsync(
    [
        new SystemChatMessage("You are a helpful assistant that talks like a pirate."),
        new UserChatMessage("Does Azure OpenAI support customer managed keys?"),
        new AssistantChatMessage("Yes, customer managed keys are supported by Azure OpenAI"),
        new UserChatMessage("Do other Azure AI services support this too?")
    ]);

await foreach(var chatUpdate in chatUpdates)
{
    if (chatUpdate.Role.HasValue)
    {
        Console.Write($"{chatUpdate.Role} : ");
    }
    
    foreach(var contentPart in chatUpdate.ContentUpdate)
    {
        Console.Write(contentPart.Text);
    }
}

Nettoyer les ressources

Si vous souhaitez nettoyer et supprimer une ressource Azure OpenAI, vous pouvez la supprimer. Vous devez d’abord supprimer tous les modèles déployés avant de supprimer la ressource.

• Azure portal
• Azure CLI

Étapes suivantes

• Consultez le référentiel GitHub Azure OpenAI samples (uniquement disponible en anglais) pour découvrir d’autres exemples.

Code source | Package (Go)| Exemples

Prérequis

• Un abonnement Azure - En créer un gratuitement
• Go 1.21.0 ou version ultérieure installé localement.
• Ressource Azure OpenAI Service avec le gpt-35-turbo modèle déployé. Pour plus d’informations sur le déploiement de modèle, consultez le guide de déploiement de ressources.

Configurer

Récupérer la clé et le point de terminaison

Pour effectuer correctement un appel sur Azure OpenAI, vous avez besoin d’un point de terminaison et d’une clé.

Accédez à votre ressource sur le portail Azure. La section Point de terminaison et les clés se trouvent dans la section Gestion des ressources. Copiez votre point de terminaison et votre clé d’accès, car vous aurez besoin de l’authentification de vos appels d’API. Vous pouvez utiliser soit KEY1, soit KEY2. Avoir toujours deux clés vous permet de faire pivoter et de régénérer en toute sécurité les clés sans provoquer d’interruption de service.

Variables d'environnement

Créez et affectez des variables d’environnement persistantes pour votre clé et votre point de terminaison.

setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE" 
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE" 

[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_API_KEY', 'REPLACE_WITH_YOUR_KEY_VALUE_HERE', 'User')
[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_ENDPOINT', 'REPLACE_WITH_YOUR_ENDPOINT_HERE', 'User')

export AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE"
export AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE"

Créer un exemple d’application

Créez un fichier nommé chat_completions.go. Copiez le code suivant dans le fichier chat_completions.go.

package main

import (
	"context"
	"fmt"
	"log"
	"os"

	"github.com/Azure/azure-sdk-for-go/sdk/ai/azopenai"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
)

func main() {
	azureOpenAIKey := os.Getenv("AZURE_OPENAI_API_KEY")
	modelDeploymentID := os.Getenv("YOUR_MODEL_DEPLOYMENT_NAME")
    maxTokens:= int32(400)


	// Ex: "https://<your-azure-openai-host>.openai.azure.com"
	azureOpenAIEndpoint := os.Getenv("AZURE_OPENAI_ENDPOINT")

	if azureOpenAIKey == "" || modelDeploymentID == "" || azureOpenAIEndpoint == "" {
		fmt.Fprintf(os.Stderr, "Skipping example, environment variables missing\n")
		return
	}

	keyCredential := azcore.NewKeyCredential(azureOpenAIKey)

	// In Azure OpenAI you must deploy a model before you can use it in your client. For more information
	// see here: https://learn.microsoft.com/azure/cognitive-services/openai/how-to/create-resource
	client, err := azopenai.NewClientWithKeyCredential(azureOpenAIEndpoint, keyCredential, nil)

	if err != nil {
		// TODO: Update the following line with your application specific error handling logic
		log.Printf("ERROR: %s", err)
		return
	}

	// This is a conversation in progress.
	// NOTE: all messages, regardless of role, count against token usage for this API.
	messages := []azopenai.ChatRequestMessageClassification{
		// You set the tone and rules of the conversation with a prompt as the system role.
		&azopenai.ChatRequestSystemMessage{Content: to.Ptr("You are a helpful assistant.")},

		// The user asks a question
		&azopenai.ChatRequestUserMessage{Content: azopenai.NewChatRequestUserMessageContent("Does Azure OpenAI support customer managed keys?")},

		// The reply would come back from the model. You'd add it to the conversation so we can maintain context.
		&azopenai.ChatRequestAssistantMessage{Content: to.Ptr("Yes, customer managed keys are supported by Azure OpenAI")},

		// The user answers the question based on the latest reply.
		&azopenai.ChatRequestUserMessage{Content: azopenai.NewChatRequestUserMessageContent("What other Azure Services support customer managed keys?")},

		// from here you'd keep iterating, sending responses back from ChatGPT
	}

	gotReply := false

	resp, err := client.GetChatCompletions(context.TODO(), azopenai.ChatCompletionsOptions{
		// This is a conversation in progress.
		// NOTE: all messages count against token usage for this API.
		Messages:       messages,
		DeploymentName: &modelDeploymentID,
		MaxTokens: &maxTokens,
	}, nil)

	if err != nil {
		// TODO: Update the following line with your application specific error handling logic
		log.Printf("ERROR: %s", err)
		return
	}

	for _, choice := range resp.Choices {
		gotReply = true

		if choice.ContentFilterResults != nil {
			fmt.Fprintf(os.Stderr, "Content filter results\n")

			if choice.ContentFilterResults.Error != nil {
				fmt.Fprintf(os.Stderr, "  Error:%v\n", choice.ContentFilterResults.Error)
			}

			fmt.Fprintf(os.Stderr, "  Hate: sev: %v, filtered: %v\n", *choice.ContentFilterResults.Hate.Severity, *choice.ContentFilterResults.Hate.Filtered)
			fmt.Fprintf(os.Stderr, "  SelfHarm: sev: %v, filtered: %v\n", *choice.ContentFilterResults.SelfHarm.Severity, *choice.ContentFilterResults.SelfHarm.Filtered)
			fmt.Fprintf(os.Stderr, "  Sexual: sev: %v, filtered: %v\n", *choice.ContentFilterResults.Sexual.Severity, *choice.ContentFilterResults.Sexual.Filtered)
			fmt.Fprintf(os.Stderr, "  Violence: sev: %v, filtered: %v\n", *choice.ContentFilterResults.Violence.Severity, *choice.ContentFilterResults.Violence.Filtered)
		}

		if choice.Message != nil && choice.Message.Content != nil {
			fmt.Fprintf(os.Stderr, "Content[%d]: %s\n", *choice.Index, *choice.Message.Content)
		}

		if choice.FinishReason != nil {
			// this choice's conversation is complete.
			fmt.Fprintf(os.Stderr, "Finish reason[%d]: %s\n", *choice.Index, *choice.FinishReason)
		}
	}

	if gotReply {
		fmt.Fprintf(os.Stderr, "Received chat completions reply\n")
	}

}

Ouvrez maintenant une invite de commande et exécutez :

go mod init chat_completions.go

Exécution suivante :

go mod tidy
go run chat_completions.go

Sortie

Content filter results
  Hate: sev: safe, filtered: false
  SelfHarm: sev: safe, filtered: false
  Sexual: sev: safe, filtered: false
  Violence: sev: safe, filtered: false
Content[0]: As of my last update in early 2023, in Azure, several AI services support the use of customer-managed keys (CMKs) through Azure Key Vault. This allows customers to have control over the encryption keys used to secure their data at rest. The services that support this feature typically fall under Azure's range of cognitive services and might include:

1. Azure Cognitive Search: It supports using customer-managed keys to encrypt the index data.
2. Azure Form Recognizer: For data at rest, you can use customer-managed keys for added security.
3. Azure Text Analytics: CMKs can be used for encrypting your data at rest.
4. Azure Blob Storage: While not exclusively an AI service, it's often used in conjunction with AI services to store data, and it supports customer-managed keys for encrypting blob data.

Note that the support for CMKs can vary by service and sometimes even by the specific feature within the service. Additionally, the landscape of cloud services is fast evolving, and new features, including security capabilities, are frequently added. Therefore, it's recommended to check the latest Azure documentation or contact Azure support for the most current information about CMK support for any specific Azure AI service.
Finish reason[0]: stop
Received chat completions reply

Nettoyer les ressources

Si vous souhaitez nettoyer et supprimer une ressource Azure OpenAI, vous pouvez la supprimer. Vous devez d’abord supprimer tous les modèles déployés avant de supprimer la ressource.

• Azure portal
• Azure CLI

Étapes suivantes

Consultez le référentiel GitHub Azure OpenAI samples (uniquement disponible en anglais) pour découvrir d’autres exemples.

Code source | Artefact (Maven) | Exemples | Modèle de conversation d’entreprise de la génération augmentée de récupération (RAG) | IntelliJ IDEA

Prérequis

• Un abonnement Azure - En créer un gratuitement

• La version actuelle du JDK (Java Development Kit)

• L’outil de génération Gradle ou un autre gestionnaire de dépendances.
• Une ressource Azure OpenAI Service avec les modèles gpt-35-turbo ou gpt-4 déployés. Pour plus d’informations sur le déploiement de modèle, consultez le guide de déploiement de ressources.

Configurer

Récupérer la clé et le point de terminaison

Pour effectuer correctement un appel sur Azure OpenAI, vous avez besoin d’un point de terminaison et d’une clé.

Accédez à votre ressource sur le portail Azure. La section Point de terminaison et les clés se trouvent dans la section Gestion des ressources. Copiez votre point de terminaison et votre clé d’accès, car vous aurez besoin de l’authentification de vos appels d’API. Vous pouvez utiliser soit KEY1, soit KEY2. Avoir toujours deux clés vous permet de faire pivoter et de régénérer en toute sécurité les clés sans provoquer d’interruption de service.

Variables d'environnement

Créez et affectez des variables d’environnement persistantes pour votre clé et votre point de terminaison.

setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE" 
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE" 

[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_API_KEY', 'REPLACE_WITH_YOUR_KEY_VALUE_HERE', 'User')
[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_ENDPOINT', 'REPLACE_WITH_YOUR_ENDPOINT_HERE', 'User')

export AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE"
export AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE"

Créer une application Java

Créez un projet Gradle.

Dans une fenêtre de console (telle que cmd, PowerShell ou bash), créez un répertoire pour votre application et accédez-y.

mkdir myapp && cd myapp

Exécutez la commande gradle init à partir de votre répertoire de travail. Cette commande crée des fichiers de build essentiels pour Gradle, notamment build.gradle.kts, qui est utilisé au moment de l’exécution pour créer et configurer votre application.

gradle init --type basic

Quand vous êtes invité à choisir un DSL, sélectionnez Kotlin.

Installer le Kit de développement logiciel (SDK) Java

Ce guide de démarrage rapide utilise le gestionnaire de dépendances Gradle. Vous trouverez la bibliothèque de client et des informations concernant d’autres gestionnaires de dépendances sur le référentiel central Maven.

Recherchez build.gradle.kts et ouvrez-le avec votre IDE ou votre éditeur de texte habituel. Copiez-y ensuite la configuration de build suivante. Cette configuration définit le projet sous forme d’application Java dont le point d’entrée est la classe OpenAIQuickstart. Cela importe la bibliothèque Azure AI Vision.

plugins {
    java
    application
}
application { 
    mainClass.set("OpenAIQuickstart")
}
repositories {
    mavenCentral()
}
dependencies {
    implementation(group = "com.azure", name = "azure-ai-openai", version = "1.0.0-beta.10")
    implementation("org.slf4j:slf4j-simple:1.7.9")
}

Créer un exemple d’application

1. Créez un fichier Java.

   Dans votre répertoire de travail, exécutez la commande suivante pour créer un dossier de projet source :

   mkdir -p src/main/java
   

   Accédez au nouveau dossier et créez le fichier OpenAIQuickstart.java.

2. Ouvrez OpenAIQuickstart.java dans votre éditeur ou IDE préféré, et collez le code suivant.

   package com.azure.ai.openai.usage;
   
   import com.azure.ai.openai.OpenAIClient;
   import com.azure.ai.openai.OpenAIClientBuilder;
   import com.azure.ai.openai.models.ChatChoice;
   import com.azure.ai.openai.models.ChatCompletions;
   import com.azure.ai.openai.models.ChatCompletionsOptions;
   import com.azure.ai.openai.models.ChatRequestAssistantMessage;
   import com.azure.ai.openai.models.ChatRequestMessage;
   import com.azure.ai.openai.models.ChatRequestSystemMessage;
   import com.azure.ai.openai.models.ChatRequestUserMessage;
   import com.azure.ai.openai.models.ChatResponseMessage;
   import com.azure.ai.openai.models.CompletionsUsage;
   import com.azure.core.credential.AzureKeyCredential;
   import com.azure.core.util.Configuration;
   
   import java.util.ArrayList;
   import java.util.List;
   
   
   public class OpenAIQuickstart {
   
       public static void main(String[] args) {
           String azureOpenaiKey = Configuration.getGlobalConfiguration().get("AZURE_OPENAI_API_KEY");
           String endpoint = Configuration.getGlobalConfiguration().get("AZURE_OPENAI_ENDPOINT");
           String deploymentOrModelId = "{azure-open-ai-deployment-model-id}";
   
           OpenAIClient client = new OpenAIClientBuilder()
               .endpoint(endpoint)
               .credential(new AzureKeyCredential(azureOpenaiKey))
               .buildClient();
   
           List<ChatRequestMessage> chatMessages = new ArrayList<>();
           chatMessages.add(new ChatRequestSystemMessage("You are a helpful assistant."));
           chatMessages.add(new ChatRequestUserMessage("Does Azure OpenAI support customer managed keys?"));
           chatMessages.add(new ChatRequestAssistantMessage("Yes, customer managed keys are supported by Azure OpenAI?"));
           chatMessages.add(new ChatRequestUserMessage("Do other Azure AI services support this too?"));    
   
           ChatCompletions chatCompletions = client.getChatCompletions(deploymentOrModelId, new ChatCompletionsOptions(chatMessages));
   
           System.out.printf("Model ID=%s is created at %s.%n", chatCompletions.getId(), chatCompletions.getCreatedAt());
           for (ChatChoice choice : chatCompletions.getChoices()) {
               ChatResponseMessage message = choice.getMessage();
               System.out.printf("Index: %d, Chat Role: %s.%n", choice.getIndex(), message.getRole());
               System.out.println("Message:");
               System.out.println(message.getContent());
           }
   
           System.out.println();
           CompletionsUsage usage = chatCompletions.getUsage();
           System.out.printf("Usage: number of prompt token is %d, "
                   + "number of completion token is %d, and number of total tokens in request and response is %d.%n",
               usage.getPromptTokens(), usage.getCompletionTokens(), usage.getTotalTokens());
       }
   }
   

   Important

   Pour la production, utilisez un moyen sécurisé de stocker et d’accéder à vos informations d’identification comme Azure Key Vault. Pour plus d’informations sur la sécurité des informations d’identification, consultez l’article de sécurité Azure AI services.

3. Revenez au dossier racine du projet et générez l’application avec :

   gradle build
   

   Ensuite, exécutez-la avec la commande gradle run :

   gradle run
   

Output

Model ID=chatcmpl-7JYnyE4zpd5gaIfTRH7hNpeVsvAw4 is created at 1684896378.
Index: 0, Chat Role: assistant.
Message:
Yes, most of the Azure AI services support customer managed keys. However, there may be some exceptions, so it is best to check the documentation of each specific service to confirm.

Usage: number of prompt token is 59, number of completion token is 36, and number of total tokens in request and response is 95.

Nettoyer les ressources

Si vous souhaitez nettoyer et supprimer une ressource Azure OpenAI, vous pouvez la supprimer. Vous devez d’abord supprimer tous les modèles déployés avant de supprimer la ressource.

• Azure portal
• Azure CLI

Étapes suivantes

• Consultez le référentiel GitHub Azure OpenAI Samples (uniquement disponible en anglais) pour découvrir d’autres exemples.

Code source | Artefacts (Maven) | Échantillon

Prérequis

• Un abonnement Azure - En créer un gratuitement
• La version actuelle du JDK (Java Development Kit)
• L’outil CLI Spring Boot
• Ressource Azure OpenAI Service avec le gpt-35-turbo modèle déployé. Pour plus d’informations sur le déploiement de modèle, consultez le guide de déploiement de ressources. Cet exemple suppose que le nom de votre déploiement correspond au nom du modèle gpt-35-turbo

Configurer

Récupérer la clé et le point de terminaison

Pour effectuer correctement un appel sur Azure OpenAI, vous avez besoin d’un point de terminaison et d’une clé.

Accédez à votre ressource sur le portail Azure. La section Point de terminaison et les clés se trouvent dans la section Gestion des ressources. Copiez votre point de terminaison et votre clé d’accès, car vous aurez besoin de l’authentification de vos appels d’API. Vous pouvez utiliser soit KEY1, soit KEY2. Avoir toujours deux clés vous permet de faire pivoter et de régénérer en toute sécurité les clés sans provoquer d’interruption de service.

Variables d'environnement

Créez et affectez des variables d’environnement persistantes pour votre clé et votre point de terminaison.

export SPRING_AI_AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE"
export SPRING_AI_AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE"
export SPRING_AI_AZURE_OPENAI_MODEL="REPLACE_WITH_YOUR_MODEL_NAME_HERE"

Créer une application Spring

Créez un projet Spring.

Dans une fenêtre Bash, créez un répertoire pour votre application et accédez-y.

mkdir ai-chat-demo && cd ai-chat-demo

Exécutez la commande spring init à partir de votre répertoire de travail. Cette commande crée une structure de répertoires standard pour votre projet Spring, y compris le fichier source de classe Java principal et le fichier pom.xml utilisé pour la gestion des projets Maven.

spring init -a ai-chat-demo -n AIChat --force --build maven -x

Les fichiers et dossiers générés ressemblent à la structure suivante :

ai-chat-demo/
|-- pom.xml
|-- mvn
|-- mvn.cmd
|-- HELP.md
|-- src/
    |-- main/
    |   |-- resources/
    |   |   |-- application.properties
    |   |-- java/
    |       |-- com/
    |           |-- example/
    |               |-- aichatdemo/
    |                   |-- AiChatApplication.java
    |-- test/
        |-- java/
            |-- com/
                |-- example/
                    |-- aichatdemo/
                        |-- AiChatApplicationTests.java

Modifier l’application Spring

1. Modifiez le fichier pom.xml.

   À partir de la racine du répertoire du projet, ouvrez le fichier pom.xml dans votre éditeur ou IDE préféré et remplacez le fichier par le contenu suivant :

   <?xml version="1.0" encoding="UTF-8"?>
   <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
       <modelVersion>4.0.0</modelVersion>
       <parent>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-parent</artifactId>
           <version>3.2.0</version>
           <relativePath/> <!-- lookup parent from repository -->
       </parent>
       <groupId>com.example</groupId>
       <artifactId>ai-chat-demo</artifactId>
       <version>0.0.1-SNAPSHOT</version>
       <name>AIChat</name>
       <description>Demo project for Spring Boot</description>
       <properties>
           <java.version>17</java.version>
       </properties>
       <dependencies>
           <dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-starter</artifactId>
           </dependency>
           <dependency>
               <groupId>org.springframework.experimental.ai</groupId>
               <artifactId>spring-ai-azure-openai-spring-boot-starter</artifactId>
               <version>0.7.0-SNAPSHOT</version>
           </dependency>
           <dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-starter-test</artifactId>
               <scope>test</scope>
           </dependency>
       </dependencies>
       <build>
           <plugins>
               <plugin>
                   <groupId>org.springframework.boot</groupId>
                   <artifactId>spring-boot-maven-plugin</artifactId>
               </plugin>
           </plugins>
       </build>
       <repositories>
           <repository>
               <id>spring-snapshots</id>
               <name>Spring Snapshots</name>
               <url>https://repo.spring.io/snapshot</url>
               <releases>
                   <enabled>false</enabled>
               </releases>
           </repository>
       </repositories>
   </project>
   

2. À partir du dossier src/main/java/com/example/aichatdemo, ouvrez AiChatApplication.java dans votre éditeur ou IDE préféré et collez le code suivant :

   package com.example.aichatdemo;
   
   import java.util.ArrayList;
   import java.util.List;
   
   import org.springframework.ai.client.AiClient;
   import org.springframework.ai.prompt.Prompt;
   import org.springframework.ai.prompt.messages.ChatMessage;
   import org.springframework.ai.prompt.messages.Message;
   import org.springframework.ai.prompt.messages.MessageType;
   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.boot.CommandLineRunner;
   import org.springframework.boot.SpringApplication;
   import org.springframework.boot.autoconfigure.SpringBootApplication;
   
   @SpringBootApplication
   public class AiChatApplication implements CommandLineRunner
   {
       private static final String ROLE_INFO_KEY = "role";
   
       @Autowired
       private AiClient aiClient;
   
       public static void main(String[] args) {
           SpringApplication.run(AiChatApplication.class, args);
       }
   
       @Override
       public void run(String... args) throws Exception
       {
           System.out.println(String.format("Sending chat prompts to AI service. One moment please...\r\n"));
   
           final List<Message> msgs = new ArrayList<>();
   
           msgs.add(new ChatMessage(MessageType.SYSTEM, "You are a helpful assistant"));
           msgs.add(new ChatMessage(MessageType.USER, "Does Azure OpenAI support customer managed keys?"));
           msgs.add(new ChatMessage(MessageType.ASSISTANT, "Yes, customer managed keys are supported by Azure OpenAI?"));
           msgs.add(new ChatMessage(MessageType.USER, "Do other Azure AI services support this too?"));
   
           final var resps = aiClient.generate(new Prompt(msgs));
   
           System.out.println(String.format("Prompt created %d generated response(s).", resps.getGenerations().size()));
   
           resps.getGenerations().stream()
             .forEach(gen -> {
                 final var role = gen.getInfo().getOrDefault(ROLE_INFO_KEY, MessageType.ASSISTANT.getValue());
   
                 System.out.println(String.format("Generated respose from \"%s\": %s", role, gen.getText()));
             });
       }
   
   }
   

   Important

   Pour la production, utilisez un moyen sécurisé de stocker et d’accéder à vos informations d’identification comme Azure Key Vault. Pour plus d’informations sur la sécurité des informations d’identification, consultez l’article de sécurité Azure AI services.

3. Revenez au dossier racine du projet et exécutez l’application à l’aide de la commande suivante :

   ./mvnw spring-boot:run
   

Sortie

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::                (v3.1.5)

2023-11-07T13:31:10.884-06:00  INFO 6248 --- [           main] c.example.aichatdemo.AiChatApplication   : No active profile set, falling back to 1 default profile: "default"
2023-11-07T13:31:11.595-06:00  INFO 6248 --- [           main] c.example.aichatdemo.AiChatApplication   : Started AiChatApplication in 0.994 seconds (process running for 1.28)
Sending chat prompts to AI service. One moment please...

Prompt created 1 generated response(s).
Generated respose from "assistant": Yes, other Azure AI services also support customer managed keys. Azure AI Services, Azure Machine Learning, and other AI services in Azure provide options for customers to manage and control their encryption keys. This allows customers to have greater control over their data and security.

Nettoyer les ressources

Si vous souhaitez nettoyer et supprimer une ressource Azure OpenAI, vous pouvez la supprimer. Vous devez d’abord supprimer tous les modèles déployés avant de supprimer la ressource.

• Azure portal
• Azure CLI

Étapes suivantes

Consultez le référentiel GitHub Azure OpenAI Samples (uniquement disponible en anglais) pour découvrir d’autres exemples.

Code source | Package (npm) | Exemples

Prérequis

• Un abonnement Azure - En créer un gratuitement
• Versions LTS de Node.js
• Azure CLI est utilisé pour l’authentification sans mot de passe dans un environnement de développement local. Créez le contexte nécessaire en vous connectant avec Azure CLI.
• Ressource Azure OpenAI Service avec des modèles de série gpt-35-turbo ou gpt-4 déployés. Pour plus d’informations sur le déploiement de modèle, consultez le guide de déploiement de ressources.

Configurer

Récupérer la clé et le point de terminaison

Pour effectuer correctement un appel sur Azure OpenAI, vous avez besoin d’un point de terminaison et d’une clé.

Accédez à votre ressource sur le portail Azure. La section Point de terminaison et les clés se trouvent dans la section Gestion des ressources. Copiez votre point de terminaison et votre clé d’accès, car vous aurez besoin de l’authentification de vos appels d’API. Vous pouvez utiliser soit KEY1, soit KEY2. Avoir toujours deux clés vous permet de faire pivoter et de régénérer en toute sécurité les clés sans provoquer d’interruption de service.

Variables d'environnement

Créez et affectez des variables d’environnement persistantes pour votre clé et votre point de terminaison.

setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE" 
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE" 

[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_API_KEY', 'REPLACE_WITH_YOUR_KEY_VALUE_HERE', 'User')
[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_ENDPOINT', 'REPLACE_WITH_YOUR_ENDPOINT_HERE', 'User')

export AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE"
export AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE"

Créer une application Node

Dans une fenêtre de console (telle que cmd, PowerShell ou bash), créez un répertoire pour votre application et accédez-y.

Installer la bibliothèque de client

Installez les packages requis pour JavaScript avec npm dans le contexte de votre nouveau répertoire :

npm install openai @azure/identity

Le fichier package.json de votre application sera mis à jour avec les dépendances.

Créer un exemple d’application

Ouvrez une invite de commandes à l’emplacement où vous souhaitez placer le nouveau projet, puis créez un fichier nommé ChatCompletion.js. Copiez le code suivant dans le fichier ChatCompletion.js.

const { AzureOpenAI } = require("openai");
const { 
  DefaultAzureCredential, 
  getBearerTokenProvider 
} = require("@azure/identity");

// You will need to set these environment variables or edit the following values
const endpoint = process.env["AZURE_OPENAI_ENDPOINT"] || "<endpoint>";
const apiVersion = "2024-05-01-preview";
const deployment = "gpt-4o"; //This must match your deployment name.


// keyless authentication    
const credential = new DefaultAzureCredential();
const scope = "https://cognitiveservices.azure.com/.default";
const azureADTokenProvider = getBearerTokenProvider(credential, scope);

async function main() {

  const client = new AzureOpenAI({ endpoint, apiKey, azureADTokenProvider, deployment });
  const result = await client.chat.completions.create({
    messages: [
    { role: "system", content: "You are a helpful assistant." },
    { role: "user", content: "Does Azure OpenAI support customer managed keys?" },
    { role: "assistant", content: "Yes, customer managed keys are supported by Azure OpenAI?" },
    { role: "user", content: "Do other Azure AI services support this too?" },
    ],
    model: "",
  });

  for (const choice of result.choices) {
    console.log(choice.message);
  }
}

main().catch((err) => {
  console.error("The sample encountered an error:", err);
});

module.exports = { main };

node.exe ChatCompletion.js

const { AzureOpenAI } = require("openai");

// You will need to set these environment variables or edit the following values
const endpoint = process.env["AZURE_OPENAI_ENDPOINT"] || "<endpoint>";
const apiKey = process.env["AZURE_OPENAI_API_KEY"] || "<api key>";
const apiVersion = "2024-05-01-preview";
const deployment = "gpt-4o"; //This must match your deployment name.

async function main() {

  const client = new AzureOpenAI({ endpoint, apiKey, apiVersion, deployment });
  const result = await client.chat.completions.create({
    messages: [
    { role: "system", content: "You are a helpful assistant." },
    { role: "user", content: "Does Azure OpenAI support customer managed keys?" },
    { role: "assistant", content: "Yes, customer managed keys are supported by Azure OpenAI?" },
    { role: "user", content: "Do other Azure AI services support this too?" },
    ],
    model: "",
  });

  for (const choice of result.choices) {
    console.log(choice.message);
  }
}

main().catch((err) => {
  console.error("The sample encountered an error:", err);
});

module.exports = { main };

node.exe ChatCompletion.js

Sortie

== Chat Completions Sample ==
{
  content: 'Yes, several other Azure AI services also support customer managed keys for enhanced security and control over encryption keys.',
  role: 'assistant'
}

Nettoyer les ressources

Si vous souhaitez nettoyer et supprimer une ressource Azure OpenAI, vous pouvez la supprimer. Vous devez d’abord supprimer tous les modèles déployés avant de supprimer la ressource.

• Azure portal
• Azure CLI

Étapes suivantes

• Vue d’ensemble d’Azure OpenAI
• Consultez le référentiel GitHub Azure OpenAI Samples (uniquement disponible en anglais) pour découvrir d’autres exemples.

Code source | Package (npm) | Exemples

Prérequis

• Un abonnement Azure - En créer un gratuitement
• Versions LTS de Node.js
• TypeScript
• Azure CLI est utilisé pour l’authentification sans mot de passe dans un environnement de développement local. Créez le contexte nécessaire en vous connectant avec Azure CLI.
• Une ressource Azure OpenAI Service avec des modèles de série gpt-35-turbo ou gpt-4 déployés. Pour plus d’informations sur le déploiement de modèle, consultez le guide de déploiement de ressources.

Configurer

Récupérer la clé et le point de terminaison

Pour effectuer correctement un appel sur Azure OpenAI, vous avez besoin d’un point de terminaison et d’une clé.

Accédez à votre ressource sur le portail Azure. La section Point de terminaison et les clés se trouvent dans la section Gestion des ressources. Copiez votre point de terminaison et votre clé d’accès, car vous aurez besoin de l’authentification de vos appels d’API. Vous pouvez utiliser soit KEY1, soit KEY2. Avoir toujours deux clés vous permet de faire pivoter et de régénérer en toute sécurité les clés sans provoquer d’interruption de service.

Variables d'environnement

Créez et affectez des variables d’environnement persistantes pour votre clé et votre point de terminaison.

setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE" 
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE" 

[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_API_KEY', 'REPLACE_WITH_YOUR_KEY_VALUE_HERE', 'User')
[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_ENDPOINT', 'REPLACE_WITH_YOUR_ENDPOINT_HERE', 'User')

export AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE"
export AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE"

Créer une application Node

Dans une fenêtre de console (telle que cmd, PowerShell ou bash), créez un répertoire pour votre application et accédez-y.

Installer la bibliothèque de client

Installez les packages requis pour JavaScript avec npm dans le contexte de votre nouveau répertoire :

npm install openai @azure/identity

Le fichier package.json de votre application sera mis à jour avec les dépendances.

Créer un exemple d’application

Ouvrez une invite de commandes à l’emplacement où vous souhaitez placer le nouveau projet, puis créez un fichier nommé ChatCompletion.ts. Copiez le code suivant dans le fichier ChatCompletion.ts.

import { AzureOpenAI } from "openai";
import { 
  DefaultAzureCredential, 
  getBearerTokenProvider 
} from "@azure/identity";
import type {
  ChatCompletion,
  ChatCompletionCreateParamsNonStreaming,
} from "openai/resources/index";

// You will need to set these environment variables or edit the following values
const endpoint = process.env["AZURE_OPENAI_ENDPOINT"] || "<endpoint>";

// Required Azure OpenAI deployment name and API version
const apiVersion = "2024-08-01-preview";
const deploymentName = "gpt-4o-mini"; //This must match your deployment name.

// keyless authentication    
const credential = new DefaultAzureCredential();
const scope = "https://cognitiveservices.azure.com/.default";
const azureADTokenProvider = getBearerTokenProvider(credential, scope);

function getClient(): AzureOpenAI {
  return new AzureOpenAI({
    endpoint,
    azureADTokenProvider,
    apiVersion,
    deployment: deploymentName,
  });
}

function createMessages(): ChatCompletionCreateParamsNonStreaming {
  return {
    messages: [
      { role: "system", content: "You are a helpful assistant." },
      {
        role: "user",
        content: "Does Azure OpenAI support customer managed keys?",
      },
      {
        role: "assistant",
        content: "Yes, customer managed keys are supported by Azure OpenAI?",
      },
      { role: "user", content: "Do other Azure AI services support this too?" },
    ],
    model: "",
  };
}
async function printChoices(completion: ChatCompletion): Promise<void> {
  for (const choice of completion.choices) {
    console.log(choice.message);
  }
}
export async function main() {
  const client = getClient();
  const messages = createMessages();
  const result = await client.chat.completions.create(messages);
  await printChoices(result);
}

main().catch((err) => {
  console.error("The sample encountered an error:", err);
});

tsc

node.exe ChatCompletion.js

import { AzureOpenAI } from "openai";
import type {
  ChatCompletion,
  ChatCompletionCreateParamsNonStreaming,
} from "openai/resources/index";

// You will need to set these environment variables or edit the following values
const endpoint = process.env["AZURE_OPENAI_ENDPOINT"] || "<endpoint>";
const apiKey = process.env["AZURE_OPENAI_API_KEY"] || "<api key>";

// Required Azure OpenAI deployment name and API version
const apiVersion = "2024-08-01-preview";
const deploymentName = "gpt-4o-mini"; //This must match your deployment name.

function getClient(): AzureOpenAI {
  return new AzureOpenAI({
    endpoint,
    apiKey,
    apiVersion,
    deployment: deploymentName,
  });
}

function createMessages(): ChatCompletionCreateParamsNonStreaming {
  return {
    messages: [
      { role: "system", content: "You are a helpful assistant." },
      {
        role: "user",
        content: "Does Azure OpenAI support customer managed keys?",
      },
      {
        role: "assistant",
        content: "Yes, customer managed keys are supported by Azure OpenAI?",
      },
      { role: "user", content: "Do other Azure AI services support this too?" },
    ],
    model: "",
  };
}
async function printChoices(completion: ChatCompletion): Promise<void> {
  for (const choice of completion.choices) {
    console.log(choice.message);
  }
}
export async function main() {
  const client = getClient();
  const messages = createMessages();
  const result = await client.chat.completions.create(messages);
  await printChoices(result);
}

main().catch((err) => {
  console.error("The sample encountered an error:", err);
});

tsc

node.exe ChatCompletion.js

Sortie

== Chat Completions Sample ==
{
  content: 'Yes, several other Azure AI services also support customer managed keys for enhanced security and control over encryption keys.',
  role: 'assistant'
}

Nettoyer les ressources

Si vous souhaitez nettoyer et supprimer une ressource Azure OpenAI, vous pouvez la supprimer. Vous devez d’abord supprimer tous les modèles déployés avant de supprimer la ressource.

• Azure portal
• Azure CLI

Étapes suivantes

• Vue d’ensemble d’Azure OpenAI
• Consultez le référentiel GitHub Azure OpenAI samples (uniquement disponible en anglais) pour découvrir d’autres exemples.

Code source de la bibliothèque | Package (PyPi) | Modèle de conversation d’entreprise de la génération augmentée de récupération (RAG) |

Prérequis

• Un abonnement Azure - En créer un gratuitement
• Python 3.8 ou version ultérieure.
• Bibliothèques Python suivantes : os.
• Une ressource Azure OpenAI Service avec les modèles gpt-35-turbo ou gpt-4 déployés. Pour plus d’informations sur le déploiement de modèle, consultez le guide de déploiement de ressources.

Configurer

Installez la bibliothèque de client Python OpenAI avec :

pip install openai

pip install openai==0.28.1

Récupérer la clé et le point de terminaison

Pour effectuer correctement un appel sur Azure OpenAI, vous avez besoin d’un point de terminaison et d’une clé.

Accédez à votre ressource sur le portail Azure. La section Point de terminaison et les clés se trouvent dans la section Gestion des ressources. Copiez votre point de terminaison et votre clé d’accès, car vous aurez besoin de l’authentification de vos appels d’API. Vous pouvez utiliser soit KEY1, soit KEY2. Avoir toujours deux clés vous permet de faire pivoter et de régénérer en toute sécurité les clés sans provoquer d’interruption de service.

Variables d'environnement

Créez et affectez des variables d’environnement persistantes pour votre clé et votre point de terminaison.

setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE" 
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE" 

[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_API_KEY', 'REPLACE_WITH_YOUR_KEY_VALUE_HERE', 'User')
[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_ENDPOINT', 'REPLACE_WITH_YOUR_ENDPOINT_HERE', 'User')

export AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE"
export AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE"

Créer une application Python

1. Créez un fichier Python appelé quickstart.py. Ensuite, ouvrez-le dans l’éditeur ou l’IDE de votre choix.

2. Remplacez le contenu du fichier quickstart.py par le code suivant.

import os
from openai import AzureOpenAI

client = AzureOpenAI(
  azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT"), 
  api_key=os.getenv("AZURE_OPENAI_API_KEY"),  
  api_version="2024-02-01"
)

response = client.chat.completions.create(
    model="gpt-35-turbo", # model = "deployment_name".
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Does Azure OpenAI support customer managed keys?"},
        {"role": "assistant", "content": "Yes, customer managed keys are supported by Azure OpenAI."},
        {"role": "user", "content": "Do other Azure AI services support this too?"}
    ]
)

print(response.choices[0].message.content)

import os
import openai
openai.api_type = "azure"
openai.api_base = os.getenv("AZURE_OPENAI_ENDPOINT") 
openai.api_key = os.getenv("AZURE_OPENAI_API_KEY")
openai.api_version = "2024-02-01"

response = openai.ChatCompletion.create(
    engine="gpt-35-turbo", # engine = "deployment_name".
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Does Azure OpenAI support customer managed keys?"},
        {"role": "assistant", "content": "Yes, customer managed keys are supported by Azure OpenAI."},
        {"role": "user", "content": "Do other Azure AI services support this too?"}
    ]
)

print(response)
print(response['choices'][0]['message']['content'])

3. Exécutez l’application avec la commande python de votre fichier de démarrage rapide :

   python quickstart.py
   

Output

{
  "choices": [
    {
      "finish_reason": "stop",
      "index": 0,
      "message": {
        "content": "Yes, most of the Azure AI services support customer managed keys. However, not all services support it. You can check the documentation of each service to confirm if customer managed keys are supported.",
        "role": "assistant"
      }
    }
  ],
  "created": 1679001781,
  "id": "chatcmpl-6upLpNYYOx2AhoOYxl9UgJvF4aPpR",
  "model": "gpt-3.5-turbo-0301",
  "object": "chat.completion",
  "usage": {
    "completion_tokens": 39,
    "prompt_tokens": 58,
    "total_tokens": 97
  }
}
Yes, most of the Azure AI services support customer managed keys. However, not all services support it. You can check the documentation of each service to confirm if customer managed keys are supported.

Présentation de la structure des messages

Les modèles GPT-35-Turbo et GPT-4 sont optimisés pour fonctionner avec des entrées au format de conversation. La variable messages transmet un tableau de dictionnaires avec différents rôles dans la conversation délimités par système, utilisateur et assistant. Le message système qui peut être utilisé pour amorcer le modèle en intégrant du contexte ou des instructions de réponse du modèle.

Le Guide pratique de GPT-35-Turbo et GPT-4 fournit une introduction détaillée aux options pour communiquer avec ces nouveaux modèles.

Nettoyer les ressources

Si vous souhaitez nettoyer et supprimer une ressource Azure OpenAI, vous pouvez la supprimer. Vous devez d’abord supprimer tous les modèles déployés avant de supprimer la ressource.

• Azure portal
• Azure CLI

Étapes suivantes

• En savoir plus sur l’utilisation des modèles GPT-35-Turbo et GPT-4 avec notre guide pratique.
• Consultez le référentiel GitHub Azure OpenAI samples (uniquement disponible en anglais) pour découvrir d’autres exemples.

Spécification de l’API REST |

Prérequis

• Un abonnement Azure : créez-en un gratuitement.
• Une ressource Azure OpenAI Service avec les modèles gpt-35-turbo ou gpt-4 déployés. Pour plus d’informations sur le déploiement de modèle, consultez le guide de déploiement de ressources.

Configurer

Récupérer la clé et le point de terminaison

Pour effectuer correctement un appel sur Azure OpenAI, vous avez besoin d’un point de terminaison et d’une clé.

Accédez à votre ressource sur le portail Azure. La section Point de terminaison et les clés se trouvent dans la section Gestion des ressources. Copiez votre point de terminaison et votre clé d’accès, car vous aurez besoin de l’authentification de vos appels d’API. Vous pouvez utiliser soit KEY1, soit KEY2. Avoir toujours deux clés vous permet de faire pivoter et de régénérer en toute sécurité les clés sans provoquer d’interruption de service.

Variables d'environnement

Créez et affectez des variables d’environnement persistantes pour votre clé et votre point de terminaison.

setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE" 
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE" 

[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_API_KEY', 'REPLACE_WITH_YOUR_KEY_VALUE_HERE', 'User')
[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_ENDPOINT', 'REPLACE_WITH_YOUR_ENDPOINT_HERE', 'User')

export AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE"
export AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE"

API REST

Dans un interpréteur de commandes bash, exécutez la commande suivante. Vous devez remplacer gpt-35-turbo par le nom de déploiement que vous avez choisi lors du déploiement des modèles GPT-35-Turbo ou GPT-4. L’entrée du nom du modèle entraîne une erreur, sauf si vous avez choisi un nom de déploiement identique au nom du modèle sous-jacent.

curl $AZURE_OPENAI_ENDPOINT/openai/deployments/gpt-35-turbo/chat/completions?api-version=2024-02-01 \
  -H "Content-Type: application/json" \
  -H "api-key: $AZURE_OPENAI_API_KEY" \
  -d '{"messages":[{"role": "system", "content": "You are a helpful assistant."},{"role": "user", "content": "Does Azure OpenAI support customer managed keys?"},{"role": "assistant", "content": "Yes, customer managed keys are supported by Azure OpenAI."},{"role": "user", "content": "Do other Azure AI services support this too?"}]}'

Le format de votre première ligne de la commande avec un exemple de point de terminaison s’affiche comme suit curl https://docs-test-001.openai.azure.com/openai/deployments/{YOUR-DEPLOYMENT_NAME_HERE}/chat/completions?api-version=2024-02-01 \. Si vous rencontrez une double vérification d’erreur pour vous assurer que vous n’avez pas de doublement de / au niveau de la séparation entre votre point de terminaison et /openai/deployments.

Si vous souhaitez exécuter cette commande dans une invite de commandes Windows normale, vous devez modifier le texte pour supprimer les \ et le sauts de ligne.

Output

{"id":"chatcmpl-6v7mkQj980V1yBec6ETrKPRqFjNw9",
"object":"chat.completion","created":1679072642,
"model":"gpt-35-turbo",
"usage":{"prompt_tokens":58,
"completion_tokens":68,
"total_tokens":126},
"choices":[{"message":{"role":"assistant",
"content":"Yes, other Azure AI services also support customer managed keys. Azure AI services offer multiple options for customers to manage keys, such as using Azure Key Vault, customer-managed keys in Azure Key Vault or customer-managed keys through Azure Storage service. This helps customers ensure that their data is secure and access to their services is controlled."},"finish_reason":"stop","index":0}]}

Mise en forme de sortie ajustée pour faciliter la lecture. La sortie réelle est un seul bloc de texte sans saut de ligne.

Présentation de la structure des messages

Les modèles GPT-35-Turbo et GPT-4 sont optimisés pour fonctionner avec des entrées au format de conversation. La variable messages transmet un tableau de dictionnaires avec différents rôles dans la conversation délimités par système, utilisateur et assistant. Le message système qui peut être utilisé pour amorcer le modèle en intégrant du contexte ou des instructions de réponse du modèle.

Le Guide pratique de GPT-35-Turbo et GPT-4 fournit une introduction détaillée aux options pour communiquer avec ces nouveaux modèles.

Nettoyer les ressources

Si vous souhaitez nettoyer et supprimer une ressource Azure OpenAI, vous pouvez la supprimer. Vous devez d’abord supprimer tous les modèles déployés avant de supprimer la ressource.

• Azure portal
• Azure CLI

Étapes suivantes

• En savoir plus sur l’utilisation des modèles GPT-35-Turbo et GPT-4 avec notre guide pratique.
• Consultez le référentiel GitHub Azure OpenAI samples (uniquement disponible en anglais) pour découvrir d’autres exemples.

Prérequis

• Un abonnement Azure - En créer un gratuitement
• Vous pouvez utiliser la dernière version, PowerShell 7, ou Windows PowerShell 5.1.
• Ressource Azure OpenAI Service avec un modèle déployé. Pour plus d’informations sur le déploiement de modèle, consultez le guide de déploiement de ressources.
• Une ressource Azure OpenAI Service avec les modèles gpt-35-turbo ou gpt-4 déployés. Pour plus d’informations sur le déploiement de modèle, consultez le guide de déploiement de ressources.

Récupérer la clé et le point de terminaison

Pour effectuer correctement un appel sur Azure OpenAI, vous aurez besoin d’un point de terminaison et d’une clé.

Accédez à votre ressource sur le portail Azure. Le Point de terminaison et les Clés se trouvent dans la section Gestion des ressources. Copiez votre point de terminaison et votre clé d’accès, car vous aurez besoin de l’authentification de vos appels d’API. Vous pouvez utiliser soit KEY1, soit KEY2. Avoir toujours deux clés vous permet de faire pivoter et de régénérer en toute sécurité les clés sans provoquer d’interruption de service.

Variables d'environnement

Créez et affectez des variables d’environnement persistantes pour votre clé et votre point de terminaison.

$Env:AZURE_OPENAI_API_KEY = 'YOUR_KEY_VALUE'
$Env:AZURE_OPENAI_ENDPOINT = 'YOUR_ENDPOINT'

setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE"
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE"

echo export AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE" >> /etc/environment && source /etc/environment
echo export AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE" >> /etc/environment && source /etc/environment

Créer un script PowerShell

1. Créez un fichier PowerShell nommé quickstart.ps1. Ensuite, ouvrez-le dans l’éditeur ou l’IDE de votre choix.

2. Remplacez le contenu du fichier quickstart.ps1 par le code suivant. Vous devez définir la variable engine sur le nom de déploiement que vous avez choisi lors du déploiement des modèles GPT-35-Turbo ou GPT-4. L’entrée du nom du modèle entraîne une erreur, sauf si vous avez choisi un nom de déploiement identique au nom du modèle sous-jacent.

   # Azure OpenAI metadata variables
   $openai = @{
      api_key     = $Env:AZURE_OPENAI_API_KEY
      api_base    = $Env:AZURE_OPENAI_ENDPOINT # your endpoint should look like the following https://YOUR_RESOURCE_NAME.openai.azure.com/
      api_version = '2024-02-01' # this may change in the future
      name        = 'YOUR-DEPLOYMENT-NAME-HERE' #This will correspond to the custom name you chose for your deployment when you deployed a model.
   }
   
   # Completion text
   $messages = @()
   $messages += @{
     role = 'system'
     content = 'You are a helpful assistant.'
   }
   $messages += @{
     role = 'user'
     content = 'Does Azure OpenAI support customer managed keys?'
   }
   $messages += @{
     role = 'assistant'
     content = 'Yes, customer managed keys are supported by Azure OpenAI.'
   }
   $messages += @{
     role = 'user'
     content = 'Do other Azure AI services support this too?'
   }
   
   # Header for authentication
   $headers = [ordered]@{
      'api-key' = $openai.api_key
   }
   
   # Adjust these values to fine-tune completions
   $body = [ordered]@{
      messages = $messages
   } | ConvertTo-Json
   
   # Send a request to generate an answer
   $url = "$($openai.api_base)/openai/deployments/$($openai.name)/chat/completions?api-version=$($openai.api_version)"
   
   $response = Invoke-RestMethod -Uri $url -Headers $headers -Body $body -Method Post -ContentType 'application/json'
   return $response
   

   Important

   Pour la production, utilisez un moyen sécurisé de stocker et d’accéder à vos informations d’identification, comme La gestion des secrets PowerShell dans Azure Key Vault. Pour plus d’informations sur la sécurité des informations d’identification, consultez l’article de sécurité Azure AI services.

3. Exécutez le script à l’aide de PowerShell :

   ./quickstart.ps1
   

Sortie

# the output of the script will be a .NET object containing the response
id      : chatcmpl-7sdJJRC6fDNGnfHMdfHXvPkYFbaVc
object  : chat.completion
created : 1693255177
model   : gpt-35-turbo
choices : {@{index=0; finish_reason=stop; message=}}
usage   : @{completion_tokens=67; prompt_tokens=55; total_tokens=122}

# convert the output to JSON
./quickstart.ps1 | ConvertTo-Json -Depth 3

# or to view the text returned, select the specific object property
$reponse = ./quickstart.ps1
$response.choices.message.content

Présentation de la structure des messages

Les modèles GPT-35-Turbo et GPT-4 sont optimisés pour fonctionner avec des entrées au format de conversation. La variable messages transmet un tableau de dictionnaires avec différents rôles dans la conversation délimités par système, utilisateur et assistant. Le message système qui peut être utilisé pour amorcer le modèle en intégrant du contexte ou des instructions de réponse du modèle.

Le Guide pratique de GPT-35-Turbo et GPT-4 fournit une introduction détaillée aux options pour communiquer avec ces nouveaux modèles.

Nettoyer les ressources

Si vous souhaitez nettoyer et supprimer une ressource Azure OpenAI, vous pouvez la supprimer. Vous devez d’abord supprimer tous les modèles déployés avant de supprimer la ressource.

• Azure portal
• Azure PowerShell

Étapes suivantes

• En savoir plus sur l’utilisation des modèles GPT-35-Turbo et GPT-4 avec notre guide pratique.
• Consultez le référentiel GitHub Azure OpenAI samples (uniquement disponible en anglais) pour découvrir d’autres exemples.