Événement
Créer des applications intelligentes
17 mars, 21 h - 21 mars, 10 h
Rejoignez la série de rencontres pour créer des solutions IA évolutives basées sur des cas d’usage réels avec d’autres développeurs et experts.
S’inscrire maintenantDémarrage rapide : commencer à utiliser GPT-35-Turbo et GPT-4 avec Azure OpenAI Service
Lisez cet article pour commencer à utiliser Azure OpenAI.
- 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.
Accédez à Azure AI Foundry 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 Azure AI Foundry, sélectionnez Terrain de jeu de conversation.
Commencez à explorer les capacités d’Azure OpenAI Service avec une approche sans code via le terrain de jeu de conversation d’Azure AI Foundry. À partir de cette page, vous pouvez rapidement itérer et expérimenter les fonctionnalités.
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.
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.
| 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. |
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é :
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.
Une fois que vous êtes satisfait de l’expérience, vous pouvez déployer une application web directement depuis le portail 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.
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.
- 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) |
- 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.
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.
CLI .NET
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 :
CLI .NET
dotnet build
La sortie de génération ne doit contenir aucun avertissement ni erreur.
Output
...
Build succeeded.
0 Warning(s)
0 Error(s)
...
Installez la bibliothèque de client .NET OpenAI avec :
Console
dotnet add package Azure.AI.OpenAI --prerelease
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. Sinon, vous pouvez trouver le point de terminaison via la page Déploiements dans le portail Azure AI Foundry. 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.
Créez et affectez des variables d’environnement persistantes pour votre clé et votre point de terminaison.
Important
Nous vous recommandons l’authentification Microsoft Entra ID avec les identités managées pour les ressources Azure pour éviter de stocker des informations d’identification avec vos applications qui s’exécutent dans le cloud.
Utilisez les clés API avec précaution. N'incluez pas la clé API directement dans votre code et ne la diffusez jamais publiquement. Si vous utilisez des clés API, stockez-les en lieu sûr dans Azure Key Vault, faites tourner les clés régulièrement et limitez l’accès à Azure Key Vault à l’aide du contrôle d’accès en fonction du rôle et des restrictions d’accès réseau. Pour plus d’informations sur l’utilisation sécurisée des clés API dans vos applications, consultez Clés API avec Azure Key Vault.
Pour plus d’informations sur la sécurité des services IA, consultez Authentifier les requêtes auprès d’Azure AI services.
Invite de commandes Windows
setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE"
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE"
À partir du répertoire du projet, ouvrez le fichier program.cs et remplacez le contenu par le code suivant :
C#
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.
Invite de commandes Windows
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.
C#
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);
}
}
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.
- Commencez avec le chat en utilisant votre propre exemple de données pour .NET
- Consultez le référentiel GitHub Azure OpenAI samples (uniquement disponible en anglais) pour découvrir d’autres exemples.
Code source | Package (Go)| Exemples
- 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.
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. Sinon, vous pouvez trouver le point de terminaison via la page Déploiements dans le portail Azure AI Foundry. 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.
Créez et affectez des variables d’environnement persistantes pour votre clé et votre point de terminaison.
Important
Nous vous recommandons l’authentification Microsoft Entra ID avec les identités managées pour les ressources Azure pour éviter de stocker des informations d’identification avec vos applications qui s’exécutent dans le cloud.
Utilisez les clés API avec précaution. N'incluez pas la clé API directement dans votre code et ne la diffusez jamais publiquement. Si vous utilisez des clés API, stockez-les en lieu sûr dans Azure Key Vault, faites tourner les clés régulièrement et limitez l’accès à Azure Key Vault à l’aide du contrôle d’accès en fonction du rôle et des restrictions d’accès réseau. Pour plus d’informations sur l’utilisation sécurisée des clés API dans vos applications, consultez Clés API avec Azure Key Vault.
Pour plus d’informations sur la sécurité des services IA, consultez Authentifier les requêtes auprès d’Azure AI services.
Invite de commandes Windows
setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE"
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE"
Créez un fichier nommé chat_completions.go. Copiez le code suivant dans le fichier chat_completions.go.
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 :
Invite de commandes Windows
go mod init chat_completions.go
Exécution suivante :
Invite de commandes Windows
go mod tidy
go run chat_completions.go
Output
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
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.
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
- 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.
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. Sinon, vous pouvez trouver le point de terminaison via la page Déploiements dans le portail Azure AI Foundry. 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.
Créez et affectez des variables d’environnement persistantes pour votre clé et votre point de terminaison.
Important
Nous vous recommandons l’authentification Microsoft Entra ID avec les identités managées pour les ressources Azure pour éviter de stocker des informations d’identification avec vos applications qui s’exécutent dans le cloud.
Utilisez les clés API avec précaution. N'incluez pas la clé API directement dans votre code et ne la diffusez jamais publiquement. Si vous utilisez des clés API, stockez-les en lieu sûr dans Azure Key Vault, faites tourner les clés régulièrement et limitez l’accès à Azure Key Vault à l’aide du contrôle d’accès en fonction du rôle et des restrictions d’accès réseau. Pour plus d’informations sur l’utilisation sécurisée des clés API dans vos applications, consultez Clés API avec Azure Key Vault.
Pour plus d’informations sur la sécurité des services IA, consultez Authentifier les requêtes auprès d’Azure AI services.
Invite de commandes Windows
setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE"
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE"
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.
Console
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.
Console
gradle init --type basic
Quand vous êtes invité à choisir un DSL, sélectionnez Kotlin.
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.
Kotlin
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éez un fichier Java.
Dans votre répertoire de travail, exécutez la commande suivante pour créer un dossier de projet source :
Consolemkdir -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.
Javapackage 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 :
Consolegradle buildEnsuite, exécutez-la avec la commande
gradle run:Consolegradle 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.
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.
- Commencez avec le chat en utilisant votre propre exemple de données pour Java
- Consultez le référentiel GitHub Azure OpenAI Samples (uniquement disponible en anglais) pour découvrir d’autres exemples.
Code source | Artefacts (Maven) | Échantillon
- 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
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. Sinon, vous pouvez trouver le point de terminaison via la page Déploiements dans le portail Azure AI Foundry. 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.
Créez et affectez des variables d’environnement persistantes pour votre clé et votre point de terminaison.
Important
Utilisez les clés API avec précaution. N'incluez pas la clé API directement dans votre code et ne la diffusez jamais publiquement. Si vous utilisez une clé API, stockez-la en lieu sûr dans Azure Key Vault. Pour plus d’informations sur l’utilisation sécurisée des clés API dans vos applications, consultez Clés API avec Azure Key Vault.
Pour plus d’informations sur la sécurité des services IA, consultez Authentifier les demandes auprès d’Azure AI services.
Note
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.
Bash
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éez un projet Spring.
Dans une fenêtre Bash, créez un répertoire pour votre application et accédez-y.
Bash
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.
Bash
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
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<?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 :
Javapackage 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 :
Bash./mvnw spring-boot:run
Output
. ____ _ __ _ _
/\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
\\/ ___)| |_)| | | | | || (_| | ) ) ) )
' |____| .__|_| |_|_| |_\__, | / / / /
=========|_|==============|___/=/_/_/_/
:: 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.
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.
Consultez le référentiel GitHub Azure OpenAI Samples (uniquement disponible en anglais) pour découvrir d’autres exemples.
Code source | Package (npm) | Exemples
Note
Ce guide utilise le dernier package npm OpenAI, qui prend désormais entièrement en charge Azure OpenAI. Si vous recherchez des exemples de code pour le kit SDK JavaScript hérité d’Azure OpenAI, ils sont toujours disponibles dans ce référentiel.
- 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-turboougpt-4déployés. Pour plus d’informations sur le déploiement de modèle, consultez le guide de déploiement de ressources.
Pour l’authentification sans clé recommandée avec Microsoft Entra ID, vous devez effectuer les tâches suivantes :
- Installez l’interface Azure CLI utilisée pour l’authentification sans clé avec Microsoft Entra ID.
- Attribuez le rôle
Cognitive Services Userà votre compte d’utilisateur. Vous pouvez attribuer des rôles dans le Portail Azure sous Contrôle d’accès (IAM)>Ajouter une attribution de rôle.
Vous devez récupérer les informations suivantes pour authentifier votre application auprès de votre ressource Azure OpenAI :
| Nom de la variable | Valeur |
|---|---|
AZURE_OPENAI_ENDPOINT |
Cette valeur se trouve dans la section Clés et point de terminaison quand vous examinez votre ressource à partir du portail Azure. |
AZURE_OPENAI_DEPLOYMENT_NAME |
Cette valeur correspond au nom personnalisé que vous avez choisi pour votre déploiement lorsque vous avez déployé un modèle. Cette valeur peut être trouvée dans le Portail Azure sous Gestion des ressources>Déploiements de modèles. |
OPENAI_API_VERSION |
En savoir plus sur les versions d’API. |
En savoir plus sur l’authentification sans clé et la définition de variables d’environnement.
Attention
Pour utiliser l’authentification sans clé recommandée avec le kit de développement logiciel (SDK), vérifiez que la variable d’environnement AZURE_OPENAI_API_KEY n’est pas définie.
Dans une fenêtre de console (telle que cmd, PowerShell ou bash), créez un répertoire pour votre application et accédez-y.
Installez les packages requis pour JavaScript avec npm dans le contexte de votre nouveau répertoire :
Console
npm install openai @azure/identity
Le fichier package.json de votre application est mis à jour avec les dépendances.
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.
JavaScript
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 };
Exécutez le script avec la commande suivante :
Invite de commandes Windows
node.exe ChatCompletion.js
Output
== 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'
}
Note
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 de votre système une variable d’environnement préexistante pour la clé API. Même si l’exemple de code Microsoft Entra ID ne référence pas explicitement la variable d’environnement de la clé API, si une telle variable est présente sur le système exécutant cet exemple, cette erreur est tout de même générée.
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.
- Vue d’ensemble d’Azure OpenAI
- Commencez avec le chat en utilisant votre propre exemple de données pour JavaScript
- Consultez le référentiel GitHub Azure OpenAI Samples (uniquement disponible en anglais) pour découvrir d’autres exemples.
Code source | Package (npm) | Exemples
Note
Ce guide utilise le dernier package npm OpenAI, qui prend désormais entièrement en charge Azure OpenAI. Si vous recherchez des exemples de code pour le kit SDK JavaScript hérité d’Azure OpenAI, ils sont toujours disponibles dans ce référentiel.
- 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-turboougpt-4déployés. Pour plus d’informations sur le déploiement de modèle, consultez le guide de déploiement de ressources.
Pour l’authentification sans clé recommandée avec Microsoft Entra ID, vous devez effectuer les tâches suivantes :
- Installez l’interface Azure CLI utilisée pour l’authentification sans clé avec Microsoft Entra ID.
- Attribuez le rôle
Cognitive Services Userà votre compte d’utilisateur. Vous pouvez attribuer des rôles dans le Portail Azure sous Contrôle d’accès (IAM)>Ajouter une attribution de rôle.
Vous devez récupérer les informations suivantes pour authentifier votre application auprès de votre ressource Azure OpenAI :
| Nom de la variable | Valeur |
|---|---|
AZURE_OPENAI_ENDPOINT |
Cette valeur se trouve dans la section Clés et point de terminaison quand vous examinez votre ressource à partir du portail Azure. |
AZURE_OPENAI_DEPLOYMENT_NAME |
Cette valeur correspond au nom personnalisé que vous avez choisi pour votre déploiement lorsque vous avez déployé un modèle. Cette valeur peut être trouvée dans le Portail Azure sous Gestion des ressources>Déploiements de modèles. |
OPENAI_API_VERSION |
En savoir plus sur les versions d’API. |
En savoir plus sur l’authentification sans clé et la définition de variables d’environnement.
Attention
Pour utiliser l’authentification sans clé recommandée avec le kit de développement logiciel (SDK), vérifiez que la variable d’environnement AZURE_OPENAI_API_KEY n’est pas définie.
Dans une fenêtre de console (telle que cmd, PowerShell ou bash), créez un répertoire pour votre application et accédez-y.
Installez les packages requis pour JavaScript avec npm dans le contexte de votre nouveau répertoire :
Console
npm install openai @azure/identity
Le fichier package.json de votre application est mis à jour avec les dépendances.
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.
TypeScript
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);
});
Exécutez le script en saisissant la commande suivante :
Invite de commandes Windows
tsc
Exécutez le script avec la commande suivante :
Invite de commandes Windows
node.exe ChatCompletion.js
Output
== 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'
}
Note
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 de votre système une variable d’environnement préexistante pour la clé API. Même si l’exemple de code Microsoft Entra ID ne référence pas explicitement la variable d’environnement de la clé API, si une telle variable est présente sur le système exécutant cet exemple, cette erreur est tout de même générée.
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.
- 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) |
- 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.
Installez la bibliothèque de client Python OpenAI avec :
Console
pip install openai
Note
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.
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. Sinon, vous pouvez trouver le point de terminaison via la page Déploiements dans le portail Azure AI Foundry. 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.
Créez et affectez des variables d’environnement persistantes pour votre clé et votre point de terminaison.
Important
Nous vous recommandons l’authentification Microsoft Entra ID avec les identités managées pour les ressources Azure pour éviter de stocker des informations d’identification avec vos applications qui s’exécutent dans le cloud.
Utilisez les clés API avec précaution. N'incluez pas la clé API directement dans votre code et ne la diffusez jamais publiquement. Si vous utilisez des clés API, stockez-les en lieu sûr dans Azure Key Vault, faites tourner les clés régulièrement et limitez l’accès à Azure Key Vault à l’aide du contrôle d’accès en fonction du rôle et des restrictions d’accès réseau. Pour plus d’informations sur l’utilisation sécurisée des clés API dans vos applications, consultez Clés API avec Azure Key Vault.
Pour plus d’informations sur la sécurité des services IA, consultez Authentifier les requêtes auprès d’Azure AI services.
Invite de commandes Windows
setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE"
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE"
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.
Python
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 :Consolepython quickstart.py
Console
{
"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.
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.
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.
- En savoir plus sur l’utilisation des modèles GPT-35-Turbo et GPT-4 avec notre guide pratique.
- Démarrez avec le chat à l’aide de votre propre exemple de données pour Python
- Consultez le référentiel GitHub Azure OpenAI samples (uniquement disponible en anglais) pour découvrir d’autres exemples.
- 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.
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. Sinon, vous pouvez trouver le point de terminaison via la page Déploiements dans le portail Azure AI Foundry. 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.
Créez et affectez des variables d’environnement persistantes pour votre clé et votre point de terminaison.
Important
Nous vous recommandons l’authentification Microsoft Entra ID avec les identités managées pour les ressources Azure pour éviter de stocker des informations d’identification avec vos applications qui s’exécutent dans le cloud.
Utilisez les clés API avec précaution. N'incluez pas la clé API directement dans votre code et ne la diffusez jamais publiquement. Si vous utilisez des clés API, stockez-les en lieu sûr dans Azure Key Vault, faites tourner les clés régulièrement et limitez l’accès à Azure Key Vault à l’aide du contrôle d’accès en fonction du rôle et des restrictions d’accès réseau. Pour plus d’informations sur l’utilisation sécurisée des clés API dans vos applications, consultez Clés API avec Azure Key Vault.
Pour plus d’informations sur la sécurité des services IA, consultez Authentifier les requêtes auprès d’Azure AI services.
Invite de commandes Windows
setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE"
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE"
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.
Bash
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.
Bash
{"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.
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.
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.
- 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.
- 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.
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. Sinon, vous pouvez trouver le point de terminaison via la page Déploiements dans le portail Azure AI Foundry. 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.
Créez et affectez des variables d’environnement persistantes pour votre clé et votre point de terminaison.
Important
Utilisez les clés API avec précaution. N'incluez pas la clé API directement dans votre code et ne la diffusez jamais publiquement. Si vous utilisez une clé API, stockez-la en lieu sûr dans Azure Key Vault. Pour plus d’informations sur l’utilisation sécurisée des clés API dans vos applications, consultez Clés API avec Azure Key Vault.
Pour plus d’informations sur la sécurité des services IA, consultez Authentifier les demandes auprès d’Azure AI services.
Invite de commandes Windows
setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE"
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE"
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.PowerShell# 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 :
PowerShell./quickstart.ps1
PowerShell
# 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
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.
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.
- 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.
Ressources supplémentaires
Formation
Module
Erste Schritte mit Azure OpenAI Service - Training
Azure OpenAI Service ermöglicht Softwareentwicklern, unternehmensweite generative KI-Lösungen zu erstellen.
Certification
Microsoft Certified: Azure AI Fundamentals - Certifications
Zeigen Sie Ihre Kenntnisse von grundlegenden KI-Konzepten im Zusammenhang mit der Entwicklung von Software und Diensten von Microsoft Azure zum Erstellen von KI-Lösungen.