Microsoft Foundry Models vous permet d’accéder aux modèles les plus puissants des principaux fournisseurs de modèles via un seul point de terminaison et un ensemble d’informations d’identification. Cette fonctionnalité vous permet de basculer entre les modèles et de les utiliser dans votre application sans modifier de code.
Cet article explique comment les services Foundry organisent les modèles et comment utiliser le point de terminaison d’inférence pour y accéder.
Une ressource Foundry peut avoir de nombreux déploiements de modèles. Vous payez uniquement pour l’inférence effectuée sur les déploiements de modèles. Les déploiements sont des ressources Azure, donc soumis à des stratégies Azure.
Installez le package à l’aide de votre gestionnaire de package openai , par exemple pip :
pip install openai --upgrade
Ensuite, vous pouvez utiliser le package pour consommer le modèle. L’exemple suivant montre comment créer un client pour consommer des complétions de chat :
import os
from openai import AzureOpenAI
client = AzureOpenAI(
azure_endpoint = "https://<resource>.services.ai.azure.com"
api_key=os.getenv("AZURE_INFERENCE_CREDENTIAL"),
api_version="2024-10-21",
)
Installez le package openai à l’aide de npm :
npm install openai
Ensuite, vous pouvez utiliser le package pour consommer le modèle. L’exemple suivant montre comment créer un client pour consommer des complétions de chat :
import { AzureKeyCredential } from "@azure/openai";
const endpoint = "https://<resource>.services.ai.azure.com";
const apiKey = new AzureKeyCredential(process.env.AZURE_INFERENCE_CREDENTIAL);
const apiVersion = "2024-10-21"
const client = new AzureOpenAI({
endpoint,
apiKey,
apiVersion,
"deepseek-v3-0324"
});
Ici, deepseek-v3-0324 est le nom d’un déploiement de modèle dans la ressource Microsoft Foundry.
Installez la bibliothèque OpenAI avec la commande suivante :
dotnet add package Azure.AI.OpenAI --prerelease
Vous pouvez utiliser le package pour exploiter le modèle. L’exemple suivant montre comment créer un client pour consommer des complétions de chat :
AzureOpenAIClient client = new(
new Uri("https://<resource>.services.ai.azure.com"),
new ApiKeyCredential(Environment.GetEnvironmentVariable("AZURE_INFERENCE_CREDENTIAL"))
);
Ajoutez le package à votre projet :
<dependency>
<groupId>com.azure</groupId>
<artifactId>azure-ai-openai</artifactId>
<version>1.0.0-beta.16</version>
</dependency>
Ensuite, vous pouvez utiliser le package pour consommer le modèle. L’exemple suivant montre comment créer un client pour consommer des complétions de chat :
OpenAIClient client = new OpenAIClientBuilder()
.credential(new AzureKeyCredential("{key}"))
.endpoint("https://<resource>.services.ai.azure.com")
.buildClient();
Utilisez la section de référence pour explorer la conception de l’API et les paramètres disponibles. Par exemple, la section de référence pour les complétions de chat explique comment utiliser l’itinéraire /chat/completions pour générer des prédictions basées sur des instructions formatées pour la conversation :
Demande
POST https://<resource>.services.ai.azure.com/openai/deployments/deepseek-v3-0324/chat/completions?api-version=2024-10-21
api-key: <api-key>
Content-Type: application/json
deepseek-v3-0324 Voici le nom d’un déploiement de modèle dans la ressource Foundry.
response = client.chat.completions.create(
model="deepseek-v3-0324", # Replace with your model deployment name.
messages=[
{"role": "system", "content": "You are a helpful assistant."},
{"role": "user", "content": "Explain Riemann's conjecture in 1 paragraph"}
]
)
print(response.model_dump_json(indent=2)
var messages = [
{ role: "system", content: "You are a helpful assistant" },
{ role: "user", content: "Explain Riemann's conjecture in 1 paragraph" },
];
const response = await client.chat.completions.create({ messages, model: "deepseek-v3-0324" });
console.log(response.choices[0].message.content)
ChatCompletion response = chatClient.CompleteChat(
[
new SystemChatMessage("You are a helpful assistant."),
new UserChatMessage("Explain Riemann's conjecture in 1 paragraph"),
]);
Console.WriteLine($"{response.Role}: {response.Content[0].Text}");
List<ChatRequestMessage> chatMessages = new ArrayList<>();
chatMessages.add(new ChatRequestSystemMessage("You are a helpful assistant"));
chatMessages.add(new ChatRequestUserMessage("Explain Riemann's conjecture in 1 paragraph"));
ChatCompletions chatCompletions = client.getChatCompletions("deepseek-v3-0324",
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());
}
Ici, deepseek-v3-0324 est le nom d’un déploiement de modèle dans la ressource Microsoft Foundry.
Demande
POST https://<resource>.services.ai.azure.com/openai/deployments/deepseek-v3-0324/chat/completions?api-version=2024-10-21
api-key: <api-key>
Content-Type: application/json
{
"messages": [
{
"role": "system",
"content": "You are a helpful assistant"
},
{
"role": "user",
"content": "Explain Riemann's conjecture in 1 paragraph"
}
]
}
deepseek-v3-0324 Voici le nom d’un déploiement de modèle dans la ressource Foundry.
Les modèles déployés sur les modèles Foundry dans Foundry Tools prennent en charge l’autorisation sans clé à l’aide de Microsoft Entra ID. L’autorisation sans clé améliore la sécurité, simplifie l’expérience utilisateur, réduit la complexité opérationnelle et fournit une prise en charge robuste de la conformité pour le développement moderne. Il rend l’autorisation sans clé un choix fort pour les organisations qui adoptent des solutions de gestion des identités sécurisées et évolutives.
Installez le Kit de développement logiciel (SDK) OpenAI à l’aide d’un gestionnaire de package tel que pip :
pip install openai
Pour l’authentification Microsoft Entra ID, installez également :
pip install azure-identity
Utilisez le package logiciel pour exploiter le modèle. L’exemple suivant montre comment créer un client pour consommer des achèvements de chat avec Microsoft Entra ID et effectuer un appel de test au point de terminaison de complétion de chat avec votre déploiement de modèle.
Remplacez par <resource> le nom de votre ressource Foundry. Recherchez-le dans le portail Azure ou en exécutant az cognitiveservices account list. Remplacez par DeepSeek-V3.1 votre nom de déploiement réel.
from openai import OpenAI
from azure.identity import DefaultAzureCredential, get_bearer_token_provider
token_provider = get_bearer_token_provider(
DefaultAzureCredential(),
"https://ai.azure.com/.default"
)
client = OpenAI(
base_url="https://<resource>.openai.azure.com/openai/v1/",
api_key=token_provider,
)
completion = client.chat.completions.create(
model="DeepSeek-V3.1", # Required: your deployment name
messages=[
{"role": "system", "content": "You are a helpful assistant."},
{"role": "user", "content": "What is Azure AI?"}
]
)
print(completion.choices[0].message.content)
Sortie attendue
Azure AI is a comprehensive suite of artificial intelligence services and tools from Microsoft that enables developers to build intelligent applications. It includes services for natural language processing, computer vision, speech recognition, and machine learning capabilities.
Référence : OpenAI Python SDK et DefaultAzureCredential class.
Installez le Kit de développement logiciel (SDK) OpenAI :
dotnet add package OpenAI
Pour l’authentification Microsoft Entra ID, installez également le package Azure.Identity :
dotnet add package Azure.Identity
Importez les espaces de noms suivants :
using Azure.Identity;
using OpenAI;
using OpenAI.Chat;
using System.ClientModel.Primitives;
Ensuite, utilisez le package pour exploiter le modèle. L’exemple suivant montre comment créer un client pour consommer des complétions de chat avec Microsoft Entra ID, puis effectuer un appel de test au point de terminaison des complétions de chat avec votre déploiement de modèle.
Remplacez <resource> par le nom de votre ressource Foundry (recherchez-la dans le portail Azure). Remplacez par gpt-4o-mini votre nom de déploiement réel.
#pragma warning disable OPENAI001
BearerTokenPolicy tokenPolicy = new(
new DefaultAzureCredential(),
"https://ai.azure.com/.default"
);
ChatClient client = new(
model: "gpt-4o-mini", // Your deployment name
authenticationPolicy: tokenPolicy,
options: new OpenAIClientOptions() {
Endpoint = new Uri("https://<resource>.openai.azure.com/openai/v1/")
}
);
ChatCompletion completion = client.CompleteChat(
new SystemChatMessage("You are a helpful assistant."),
new UserChatMessage("What is Azure AI?")
);
Console.WriteLine(completion.Content[0].Text);
Sortie attendue :
Azure AI is a comprehensive suite of artificial intelligence services and tools from Microsoft that enables developers to build intelligent applications. It includes services for natural language processing, computer vision, speech recognition, and machine learning capabilities.
Référence : OpenAI .NET SDK et DefaultAzureCredential class.
Installez le Kit de développement logiciel (SDK) OpenAI avec npm :
npm install openai
Pour l’authentification Microsoft Entra ID, installez également :
npm install @azure/identity
Ensuite, utilisez le package pour exploiter le modèle. L’exemple suivant montre comment créer un client pour consommer des complétions de chat avec Microsoft Entra ID, puis effectuer un appel de test au point de terminaison des complétions de chat avec votre déploiement de modèle.
Remplacez <resource> par le nom de votre ressource Foundry (recherchez-la dans le portail Azure ou en exécutant az cognitiveservices account list). Remplacez par DeepSeek-V3.1 votre nom de déploiement réel.
import { DefaultAzureCredential, getBearerTokenProvider } from "@azure/identity";
import { OpenAI } from "openai";
const tokenProvider = getBearerTokenProvider(
new DefaultAzureCredential(),
'https://ai.azure.com/.default'
);
const client = new OpenAI({
baseURL: "https://<resource>.openai.azure.com/openai/v1/",
apiKey: tokenProvider
});
const completion = await client.chat.completions.create({
model: "DeepSeek-V3.1", // Required: your deployment name
messages: [
{ role: "system", content: "You are a helpful assistant." },
{ role: "user", content: "What is Azure AI?" }
]
});
console.log(completion.choices[0].message.content);
Sortie attendue :
Azure AI is a comprehensive suite of artificial intelligence services and tools from Microsoft that enables developers to build intelligent applications. It includes services for natural language processing, computer vision, speech recognition, and machine learning capabilities.
Référence : Kit de développement logiciel (SDK) OpenAI Node.js et classe DefaultAzureCredential.
Ajoutez le Kit de développement logiciel (SDK) OpenAI à votre projet. Consultez le référentiel OpenAI Java GitHub pour obtenir les dernières instructions d’installation et de version.
Pour l’authentification Microsoft Entra ID, ajoutez également :
<dependency>
<groupId>com.azure</groupId>
<artifactId>azure-identity</artifactId>
<version>1.18.0</version>
</dependency>
Ensuite, utilisez le package pour exploiter le modèle. L’exemple suivant montre comment créer un client pour consommer des complétions de chat avec Microsoft Entra ID, puis effectuer un appel de test au point de terminaison des complétions de chat avec votre déploiement de modèle.
Remplacez <resource> par le nom de votre ressource Foundry (recherchez-la dans le portail Azure). Remplacez par DeepSeek-V3.1 votre nom de déploiement réel.
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.azure.identity.DefaultAzureCredential;
import com.azure.identity.DefaultAzureCredentialBuilder;
import com.openai.models.chat.completions.*;
DefaultAzureCredential tokenCredential = new DefaultAzureCredentialBuilder().build();
OpenAIClient client = OpenAIOkHttpClient.builder()
.baseUrl("https://<resource>.openai.azure.com/openai/v1/")
.credential(BearerTokenCredential.create(
AuthenticationUtil.getBearerTokenSupplier(
tokenCredential,
"https://ai.azure.com/.default"
)
))
.build();
ChatCompletionCreateParams params = ChatCompletionCreateParams.builder()
.addSystemMessage("You are a helpful assistant.")
.addUserMessage("What is Azure AI?")
.model("DeepSeek-V3.1") // Required: your deployment name
.build();
ChatCompletion completion = client.chat().completions().create(params);
System.out.println(completion.choices().get(0).message().content());
Sortie attendue :
Azure AI is a comprehensive suite of artificial intelligence services and tools from Microsoft that enables developers to build intelligent applications. It includes services for natural language processing, computer vision, speech recognition, and machine learning capabilities.
Référence : OpenAI Java SDK et la classe DefaultAzureCredential.
Explorez la conception de l’API dans la section référence pour voir quels paramètres sont disponibles. Indiquez le jeton d’authentification dans l’en-tête Authorization. Par exemple, la section de référence Chat completion explique comment utiliser la /chat/completions route pour générer des prédictions basées sur des instructions au format conversation. Le chemin d’accès /models est inclus à la racine de l’URL :
Demande
Remplacez <resource> par le nom de votre ressource Foundry (recherchez-la dans le portail Azure ou en exécutant az cognitiveservices account list). Remplacez par MAI-DS-R1 votre nom de déploiement réel.
La base_url acceptera à la fois les formats https://<resource>.openai.azure.com/openai/v1/ et https://<resource>.services.ai.azure.com/openai/v1/.
curl -X POST https://<resource>.openai.azure.com/openai/v1/chat/completions \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $AZURE_OPENAI_AUTH_TOKEN" \
-d '{
"model": "MAI-DS-R1",
"messages": [
{
"role": "system",
"content": "You are a helpful assistant."
},
{
"role": "user",
"content": "Explain what the bitter lesson is?"
}
]
}'
Réponse
Si l’authentification réussit, vous recevez une 200 OK réponse avec les résultats de la complétion de la conversation dans le corps de la réponse.
{
"id": "chatcmpl-...",
"object": "chat.completion",
"created": 1738368234,
"model": "MAI-DS-R1",
"choices": [
{
"index": 0,
"message": {
"role": "assistant",
"content": "The bitter lesson refers to a key insight in AI research that emphasizes the importance of general-purpose learning methods that leverage computation, rather than human-designed domain-specific approaches. It suggests that methods which scale with increased computation tend to be more effective in the long run."
},
"finish_reason": "stop"
}
],
"usage": {
"prompt_tokens": 28,
"completion_tokens": 52,
"total_tokens": 80
}
}
Les jetons doivent être émis avec le périmètre https://ai.azure.com/.default.
À des fins de test, le moyen le plus simple d’obtenir un jeton valide pour votre compte d’utilisateur consiste à utiliser le Azure CLI. Dans une console, exécutez la commande Azure CLI suivante :
az account get-access-token --resource https://cognitiveservices.azure.com --query "accessToken" --output tsv
Cette commande génère un jeton d’accès que vous pouvez stocker dans la variable d’environnement $AZURE_OPENAI_AUTH_TOKEN .
Référence : API de complétion de chat