Démarrage rapide : commencer à utiliser GPT-35-Turbo et GPT-4 avec Azure OpenAI Service
Lisez cet article pour commencer à utiliser Azure OpenAI.
Prérequis
- Un abonnement Azure : créez-en un gratuitement.
- Une ressource Azure OpenAI Service avec les modèles
gpt-4oougpt-4o-minidé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
| Nom | Description |
|---|---|
| Déploiements | Votre nom de déploiement associé à un modèle spécifique. |
| Ajouter vos données | |
| Paramètres | Paramètres personnalisés qui modifient les réponses du modèle. Lorsque de vos premières utilisations, nous vous recommandons d’utiliser les valeurs par défaut pour la plupart des paramètres |
| Température | Contrôle le caractère aléatoire. La réduction de la température signifie que le modèle produit des réponses plus répétitives et déterministes. L’augmentation de la température entraîne des réponses plus inattendues ou créatives. Essayez d’ajuster la température ou le Top P, mais pas les deux. |
| Réponse maximale (jetons) | Définissez une limite pour le nombre de jetons par réponse de modèle. L’API sur les modèles les plus récents prend en charge un maximum de 128 000 jetons partagés entre l’invite (y compris le message système, les exemples, l’historique des messages et la requête utilisateur) et la réponse du modèle. Un jeton correspond à environ quatre caractères pour un texte typique en anglais. |
| Top p | Comme la température, cela permet de contrôler le caractère aléatoire, mais en utilisant une autre méthode. La réduction du Top P limite la sélection de jetons du modèle à des jetons plus probables. L’augmentation du Top P permet au modèle de choisir parmi des jetons avec des probabilités élevées et faibles. Essayez d’ajuster la température ou le Top P, mais pas les deux. |
| Séquences d’arrêt | La séquence d’arrêt oblige le modèle de terminer sa réponse à un point souhaité. La réponse du modèle se termine avant la séquence spécifiée pour qu’elle ne contienne pas le texte de séquence d’arrêt. Pour GPT-35-Turbo, l’utilisation de <|im_end|> garantit que la réponse du modèle ne génère pas de requête utilisateur de suivi. Vous pouvez inclure jusqu’à quatre séquences d’arrêt. |
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.
Étapes suivantes
- En savoir plus sur l’utilisation du nouveau modèle
gpt-35-turboavec 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-turboougpt-4dé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é.
| Nom de la variable | Valeur |
|---|---|
ENDPOINT |
Le point de terminaison de service se trouve dans la section Clés et point de terminaison quand vous examinerez votre ressource à partir du Portail Azure. Vous pouvez également trouver le point de terminaison via la page Déploiements dans Azure AI Studio. Voici un exemple de point de terminaison : https://docs-test-001.openai.azure.com/. |
API-KEY |
Cette valeur se trouve dans la section Clés et point de terminaison quand vous examinez votre ressource à partir du portail Azure. Vous pouvez utiliser soit KEY1, soit KEY2. |
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.
Important
Si vous utilisez une clé API, stockez-la en toute sécurité dans un autre emplacement, par exemple dans Azure Key Vault. N'incluez pas la clé API directement dans votre code et ne la diffusez jamais publiquement.
Pour plus d’informations sur la sécurité des services IA, consultez Authentifier les requêtes auprès d’Azure AI services.
setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE"
setx 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}");
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.
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.
É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-turbomodè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é.
| Nom de la variable | Valeur |
|---|---|
ENDPOINT |
Le point de terminaison de service se trouve dans la section Clés et point de terminaison quand vous examinerez votre ressource à partir du Portail Azure. Vous pouvez également trouver le point de terminaison via la page Déploiements dans Azure AI Studio. Voici un exemple de point de terminaison : https://docs-test-001.openai.azure.com/. |
API-KEY |
Cette valeur se trouve dans la section Clés et point de terminaison quand vous examinez votre ressource à partir du portail Azure. Vous pouvez utiliser soit KEY1, soit KEY2. |
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.
Important
Si vous utilisez une clé API, stockez-la en toute sécurité dans un autre emplacement, par exemple dans Azure Key Vault. N'incluez pas la clé API directement dans votre code et ne la diffusez jamais publiquement.
Pour plus d’informations sur la sécurité des services IA, consultez Authentifier les requêtes auprès d’Azure AI services.
setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE"
setx 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")
}
}
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.
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.
É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-turboougpt-4dé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é.
| Nom de la variable | Valeur |
|---|---|
ENDPOINT |
Le point de terminaison de service se trouve dans la section Clés et point de terminaison quand vous examinerez votre ressource à partir du Portail Azure. Vous pouvez également trouver le point de terminaison via la page Déploiements dans Azure AI Studio. Voici un exemple de point de terminaison : https://docs-test-001.openai.azure.com/. |
API-KEY |
Cette valeur se trouve dans la section Clés et point de terminaison quand vous examinez votre ressource à partir du portail Azure. Vous pouvez utiliser soit KEY1, soit KEY2. |
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.
Important
Si vous utilisez une clé API, stockez-la en toute sécurité dans un autre emplacement, par exemple dans Azure Key Vault. N'incluez pas la clé API directement dans votre code et ne la diffusez jamais publiquement.
Pour plus d’informations sur la sécurité des services IA, consultez Authentifier les requêtes auprès d’Azure AI services.
setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE"
setx 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
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/javaAccédez au nouveau dossier et créez le fichier OpenAIQuickstart.java.
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.
Revenez au dossier racine du projet et générez l’application avec :
gradle buildEnsuite, exécutez-la avec la commande
gradle run:gradle run
Sortie
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.
É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-turbomodè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èlegpt-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é.
| Nom de la variable | Valeur |
|---|---|
ENDPOINT |
Le point de terminaison de service se trouve dans la section Clés et point de terminaison quand vous examinerez votre ressource à partir du Portail Azure. Vous pouvez également trouver le point de terminaison via la page Déploiements dans Azure AI Studio. Voici un exemple de point de terminaison : https://docs-test-001.openai.azure.com/. |
API-KEY |
Cette valeur se trouve dans la section Clés et point de terminaison quand vous examinez votre ressource à partir du portail Azure. Vous pouvez utiliser soit KEY1, soit KEY2. |
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.
Important
Si vous utilisez une clé API, stockez-la en toute sécurité dans un autre emplacement, par exemple dans Azure Key Vault. N'incluez pas la clé API directement dans votre code et ne la diffusez jamais publiquement.
Pour plus d’informations sur la sécurité des services IA, consultez Authentifier les demandes auprès d’Azure AI services.
Remarque
Spring AI affecte par défaut le nom du modèle à gpt-35-turbo. Il n’est nécessaire de fournir la valeur SPRING_AI_AZURE_OPENAI_MODEL que si vous avez déployé un modèle avec un autre nom.
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
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>À 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.
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.
É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
Remarque
Cet article a été mis à jour pour utiliser le dernier package npm OpenAI qui prend désormais entièrement en charge Azure OpenAI. Si vous cherchez des exemples de code pour le Kit de développement logiciel (SDK) JavaScript hérité d’Azure OpenAI, ils sont actuellement toujours disponibles dans ce référentiel.
Prérequis
- Un abonnement Azure - En créer un gratuitement
- Versions LTS de Node.js
- TypeScript
- Une ressource Azure OpenAI Service avec des modèles de série
gpt-35-turboougpt-4dé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é.
| Nom de la variable | Valeur |
|---|---|
ENDPOINT |
Le point de terminaison de service se trouve dans la section Clés et point de terminaison quand vous examinerez votre ressource à partir du Portail Azure. Vous pouvez également trouver le point de terminaison via la page Déploiements dans Azure AI Studio. Voici un exemple de point de terminaison : https://docs-test-001.openai.azure.com/. |
API-KEY |
Cette valeur se trouve dans la section Clés et point de terminaison quand vous examinez votre ressource à partir du portail Azure. Vous pouvez utiliser soit KEY1, soit KEY2. |
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.
Important
Si vous utilisez une clé API, stockez-la en toute sécurité dans un autre emplacement, par exemple dans Azure Key Vault. N'incluez pas la clé API directement dans votre code et ne la diffusez jamais publiquement.
Pour plus d’informations sur la sécurité des services IA, consultez Authentifier les requêtes auprès d’Azure AI services.
setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE"
setx 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 dotenv @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.
import "dotenv/config";
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);
});
Exécutez le script en saisissant la commande suivante :
tsc
Exécutez le script avec la commande suivante :
node.exe Completion.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'
}
Microsoft Entra ID
Important
Dans l’exemple précédent, nous montrons l’authentification basée sur des clés. Une fois que vous avez testé l’authentification basée sur des clés, nous vous recommandons d’utiliser l’instance Microsoft Entra ID plus sécurisée pour l’authentification, illustrée dans l’exemple de code suivant. Pour démarrer avec [Microsoft Entra ID], vous devez satisfaire quelques prérequis supplémentaires.
import {
DefaultAzureCredential,
getBearerTokenProvider,
} from "@azure/identity";
import "dotenv/config";
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>";
// 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 {
const scope = "https://cognitiveservices.azure.com/.default";
const azureADTokenProvider = getBearerTokenProvider(
new DefaultAzureCredential(),
scope
);
return new AzureOpenAI({
endpoint,
azureADTokenProvider,
deployment: deploymentName,
apiVersion,
});
}
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);
});
Remarque
Si vous recevez l’erreur Une erreur s’est produite : OpenAIError : les arguments apiKey et azureADTokenProvider s’excluent mutuellement ; un seul peut être passé à la fois. Vous devrez peut-être supprimer une variable d’environnement préexistante pour la clé API de votre système. Même si l’exemple de code Microsoft Entra ID ne référence pas explicitement la variable d’environnement de la clé API, s’il en existe une sur le système exécutant cet exemple, cette erreur est quand même générée.
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.
É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-turboougpt-4dé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
Remarque
Cette bibliothèque est gérée par OpenAI. Reportez-vous à l’historique des versions pour suivre les dernières mises à jour de la bibliothèque.
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é.
| Nom de la variable | Valeur |
|---|---|
ENDPOINT |
Le point de terminaison de service se trouve dans la section Clés et point de terminaison quand vous examinerez votre ressource à partir du Portail Azure. Vous pouvez également trouver le point de terminaison via la page Déploiements dans Azure AI Studio. Voici un exemple de point de terminaison : https://docs-test-001.openai.azure.com/. |
API-KEY |
Cette valeur se trouve dans la section Clés et point de terminaison quand vous examinez votre ressource à partir du portail Azure. Vous pouvez utiliser soit KEY1, soit KEY2. |
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.
Important
Si vous utilisez une clé API, stockez-la en toute sécurité dans un autre emplacement, par exemple dans Azure Key Vault. N'incluez pas la clé API directement dans votre code et ne la diffusez jamais publiquement.
Pour plus d’informations sur la sécurité des services IA, consultez Authentifier les requêtes auprès d’Azure AI services.
setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE"
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE"
Créer une application Python
Créez un fichier Python appelé quickstart.py. Ensuite, ouvrez-le dans l’éditeur ou l’IDE de votre choix.
Remplacez le contenu du fichier quickstart.py par le code suivant.
Vous devez définir la variable model sur le nom du déploiement que vous avez choisi quand vous avez déployé les modèles GPT-3.5-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.
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)
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.
Exécutez l’application avec la commande
pythonde votre fichier de démarrage rapide :python quickstart.py
Sortie
{
"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.
É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 : créez-en un gratuitement.
- Une ressource Azure OpenAI Service avec les modèles
gpt-35-turboougpt-4dé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é.
| Nom de la variable | Valeur |
|---|---|
ENDPOINT |
Le point de terminaison de service se trouve dans la section Clés et point de terminaison quand vous examinerez votre ressource à partir du Portail Azure. Vous pouvez également trouver le point de terminaison via la page Déploiements dans Azure AI Studio. Voici un exemple de point de terminaison : https://docs-test-001.openai.azure.com/. |
API-KEY |
Cette valeur se trouve dans la section Clés et point de terminaison quand vous examinez votre ressource à partir du portail Azure. Vous pouvez utiliser soit KEY1, soit KEY2. |
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.
Important
Si vous utilisez une clé API, stockez-la en toute sécurité dans un autre emplacement, par exemple dans Azure Key Vault. N'incluez pas la clé API directement dans votre code et ne la diffusez jamais publiquement.
Pour plus d’informations sur la sécurité des services IA, consultez Authentifier les requêtes auprès d’Azure AI services.
setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE"
setx 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.
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.
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.
É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-turboougpt-4dé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é.
| Nom de la variable | Valeur |
|---|---|
ENDPOINT |
Le point de terminaison de service se trouve dans la section Clés et point de terminaison quand vous examinerez votre ressource à partir du Portail Azure. Vous pouvez également trouver le point de terminaison via la page Déploiements dans Azure AI Studio. Voici un exemple de point de terminaison : https://docs-test-001.openai.azure.com/. |
API-KEY |
Cette valeur se trouve dans la section Clés et point de terminaison quand vous examinez votre ressource à partir du portail Azure. Vous pouvez utiliser soit KEY1, soit KEY2. |
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.
Important
Si vous utilisez une clé API, stockez-la en toute sécurité dans un autre emplacement, par exemple dans Azure Key Vault. N'incluez pas la clé API directement dans votre code et ne la diffusez jamais publiquement.
Pour plus d’informations sur la sécurité des services IA, consultez Authentifier les demandes auprès d’Azure AI services.
$Env:AZURE_OPENAI_API_KEY = 'YOUR_KEY_VALUE'
$Env:AZURE_OPENAI_ENDPOINT = 'YOUR_ENDPOINT'
Créer un script PowerShell
Créez un fichier PowerShell nommé quickstart.ps1. Ensuite, ouvrez-le dans l’éditeur ou l’IDE de votre choix.
Remplacez le contenu du fichier quickstart.ps1 par le code suivant. Vous devez définir la variable
enginesur 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 $responseImportant
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.
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.
É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.