Remarque
L’accès à cette page requiert une autorisation. Vous pouvez essayer de vous connecter ou de modifier des répertoires.
L’accès à cette page requiert une autorisation. Vous pouvez essayer de modifier des répertoires.
Affichage actuel :
Version du portail - Passer à la version du nouveau portail Foundry
Une ressource Foundry fournit un accès unifié aux modèles, aux agents et aux outils. Cet article explique le Kit de développement logiciel (SDK) et le point de terminaison à utiliser pour votre scénario.
| SDK | Champ d’utilisation | Point de terminaison |
|---|---|---|
| Kit de développement logiciel (SDK) Foundry | Fonctionnalités spécifiques à Foundry avec des interfaces compatibles OpenAI. Inclut l’accès aux modèles directs Foundry via l’API Responses (et non via Chat Completions). | https://<resource-name>.services.ai.azure.com/api/projects/<project-name> |
| Kit de développement logiciel (SDK) OpenAI | Derniers modèles et fonctionnalités du SDK OpenAI avec la surface complète de l’API OpenAI. Les modèles directs Foundry sont disponibles via l'API de Complétions de conversation (et non via l'API des réponses). | https://<resource-name>.openai.azure.com/openai/v1 |
| Kits de développement logiciel (SDK) des outils de fonderie | Solutions prédéfinies (Vision, Reconnaissance vocale, Sécurité du contenu, etc.). | Points de terminaison spécifiques à l’outil (varie selon le service). |
| Infrastructure de l’agent | Orchestration de multi-agents dans le code. Indépendant du cloud. | Utilise le point de terminaison du projet via le kit de développement logiciel (SDK) Foundry. |
Choisissez votre Kit de développement logiciel (SDK) :
- Utiliser le Kit de développement logiciel (SDK) Foundry lors de la création d’applications avec des agents, des évaluations ou des fonctionnalités spécifiques à Foundry
- Utiliser le Kit de développement logiciel (SDK) OpenAI lorsque la compatibilité OpenAI maximale est requise, ou en utilisant des modèles directs Foundry via les complétions de chat.
- Utilisez les kits SDK Foundry Tools lors de l’utilisation de services IA spécifiques (Vision, Speech, Language, etc.)
- Utiliser Agent Framework lors de la création de systèmes multi-agents dans du code (orchestration locale)
Note
Types de ressources : Une ressource Foundry fournit tous les points de terminaison précédemment répertoriés. Une ressource OpenAI Azure fournit uniquement le point de terminaison /openai/v1.
Authentication : Exemples ici utilisent Microsoft Entra ID (DefaultAzureCredential). Les clés API fonctionnent sur /openai/v1. Transmettez la clé en tant que api_key au lieu d’un fournisseur de jetons.
Prerequisites
-
Un compte Azure avec un abonnement actif. Si vous n'en avez pas, créez un compte Azure gratuit, qui inclut un abonnement d'essai gratuit.
Disposez de l’un des rôles RBAC suivants Azure pour créer et gérer des ressources Foundry :
- Rôle utilisateur Azure IA (rôle de moindre privilège pour le développement)
- Azure AI Project Manager (pour la gestion des projets Foundry)
- Contributeur ou Propriétaire (pour les autorisations au niveau de l’abonnement)
Pour plus d'informations sur les autorisations de chaque rôle, consultez le contrôle d'accès basé sur les rôles pour Microsoft Foundry.
Installez les runtimes de langage requis, les outils globaux et les extensions VS Code, comme décrit dans Préparer votre environnement de développement.
Important
Avant de commencer, assurez-vous que votre environnement de développement est prêt.
Cet article se concentre sur les étapes spécifiques au scénario , telles que l’installation, l’authentification et l’exécution d’exemples de code.
Vérifier les prérequis
Avant de continuer, confirmez ce qui suit :
- [ ] abonnement Azure est actif :
az account show - [ ] Vous disposez du rôle RBAC requis : vérifiez Azure portal → ressource Foundry → Access control (IAM)
- [ ] Runtime de langage installé :
- Python :
python --version(≥3.8) - Node.js:
node --version(≥18) - .NET :
dotnet --version(≥6.0) - Java :
java --version(≥11)
- Python :
Kit de développement logiciel (SDK) Foundry
Le Kit de développement logiciel (SDK) Foundry se connecte à un point de terminaison projet unique qui fournit un accès aux fonctionnalités de Foundry les plus populaires :
https://<resource-name>.services.ai.azure.com/api/projects/<project-name>
Note
Si votre organisation utilise un sous-domaine personnalisé, remplacez-le <resource-name><your-custom-subdomain> dans l’URL du point de terminaison.
Cette approche simplifie la configuration de l’application. Au lieu de gérer plusieurs points de terminaison, vous en configurez un.
Installer le SDK
Note
Cet article s’applique à un projet Foundry. Le code présenté ici ne fonctionne pas pour un hub project. Pour plus d'informations, voir Types de projets.
Note
Versions du Kit de développement logiciel (SDK) : Le Kit de développement logiciel (SDK) en préversion 2.x cible le nouveau portail Et l’API Foundry. Le SDK 1.x GA cible Foundry Classic. Vérifiez que les exemples que vous suivez correspondent à votre package installé.
| Version du SDK | Version du portail | Statut | Package Python |
|---|---|---|---|
| 2.x (préversion) | Fonderie (nouvelle) | Preview | azure-ai-projects>=2.0.0b1 --pre |
| 1.x (GA) | Foundry classic | Stable | azure-ai-projects==1.0.0 |
La bibliothèque cliente Azure AI Projects pour Python est une bibliothèque unifiée qui vous permet d’utiliser plusieurs bibliothèques clientes ensemble en vous connectant à un point de terminaison project unique.
Exécutez cette commande pour installer les packages stables pour les projets classiques Foundry.
pip install openai azure-identity azure-ai-projects==1.0.0
| Version du SDK | Version du portail | Statut | Java Package |
|---|---|---|---|
| 1.0.0-beta.3 1.0.0-beta.1 |
Fonderie (nouvelle) | Preview | azure-ai-projectsazure-ai-agents |
| Version du SDK | Version du portail | Statut | Paquet JavaScript |
|---|---|---|---|
| 2.0.0-beta.4 (préversion) | Fonderie (nouvelle) | Preview | @azure/ai-projects 'prerelease' |
| 1.0.1 | Foundry classic | Stable | @azure/ai-projects |
| Version du SDK | Version du portail | Statut | paquet .NET |
|---|---|---|---|
| 1.2.0-beta.5 (préversion) | Fonderie (nouvelle) | Preview | Azure.AI.ProjectsAzure.AI.Projects.Openai |
| 1.x (GA) | Foundry classic | Stable | Azure.AI.Projects |
La bibliothèque cliente Azure AI Projects pour Java (préversion) est une bibliothèque unifiée qui vous permet d’utiliser plusieurs bibliothèques clientes ensemble en vous connectant à un point de terminaison project unique.
Important
Les éléments marqués (aperçu) dans cet article sont actuellement en aperçu public. Cette version préliminaire est fournie sans contrat de niveau de service, et nous la déconseillons pour les charges de travail en production. Certaines fonctionnalités peuvent être limitées ou non prises en charge. Pour plus d’informations, consultez les Conditions d’utilisation Complémentaires de Microsoft Azure Previews.
Ajoutez ces packages à votre installation pour les projets classiques Foundry.
package com.azure.ai.foundry.samples;
import com.azure.ai.projects;
import com.azure.ai.inference.ChatCompletionsClient;
import com.azure.ai.inference.ChatCompletionsClientBuilder;
import com.azure.ai.inference.models.ChatCompletions;
import com.azure.core.credential.AzureKeyCredential;
import com.azure.core.credential.TokenCredential;
import com.azure.core.exception.HttpResponseException;
import com.azure.core.util.logging.ClientLogger;
import com.azure.identity.DefaultAzureCredentialBuilder;
La bibliothèque cliente Azure AI Projects pour JavaScript est une bibliothèque unifiée qui vous permet d’utiliser plusieurs bibliothèques clientes ensemble en vous connectant à un point de terminaison project unique.
Exécutez cette commande pour installer les packages JavaScript actuels pour les projets classiques Foundry.
npm install @azure/ai-projects @azure/identity
La bibliothèque cliente Azure AI Projects pour .NET est une bibliothèque unifiée qui vous permet d’utiliser plusieurs bibliothèques clientes ensemble en vous connectant à un point de terminaison project unique.
Exécutez ces commandes pour ajouter les packages Azure SDK AI pour les projets classiques Foundry.
# Add Azure AI SDK packages
dotnet add package Azure.Identity
dotnet add package Azure.AI.Projects
dotnet add package Azure.AI.Agents.Persistent
dotnet add package Azure.AI.Inference
Utilisation du Kit de développement logiciel (SDK) Foundry
Le Kit de développement logiciel (SDK) expose deux types de clients, car Foundry et OpenAI ont des formes d’API différentes :
- Project client : à utiliser pour les opérations natives Foundry lorsque OpenAI n’a pas d’équivalent. Exemples : lister les connexions, récupérer les propriétés du projet, activer le suivi.
-
Client compatible OpenAI : utilisez la fonctionnalité Foundry qui s’appuie sur les concepts OpenAI. L’API Réponses, les agents, les évaluations et le réglage précis utilisent tous les modèles de requête/réponse de style OpenAI. Ce client vous donne également access aux modèles directs Foundry (modèles non Azure-OpenAI hébergés dans Foundry). Le point de terminaison du projet gère ce trafic sur l’itinéraire
/openai.
La plupart des applications utilisent les deux clients. Utilisez le client project pour l’installation et la configuration, puis utilisez le client compatible OpenAI pour exécuter des agents, des évaluations et des modèles appelants (y compris les modèles directs Foundry).
Créer un client project :
from azure.ai.projects import AIProjectClient
from azure.identity import DefaultAzureCredential
project = AIProjectClient(
endpoint="https://<resource-name>.services.ai.azure.com/api/projects/<project-name>",
credential=DefaultAzureCredential(),
)
```**Create an OpenAI-compatible client from your project:**
```python
models = project_client.get_openai_client(api_version="2024-10-21")
chat_responses = models.chat.completions.create(
model="gpt-4o",
messages=[
{"role": "system", "content": "You are a helpful assistant"},
{"role": "user", "content": "What is the size of France in square miles?"},
],
)
print(chat_responses.choices[0].message.content)
Créer un client project :
package com.azure.ai.foundry.samples;
import com.azure.ai.inference.ChatCompletionsClient;
import com.azure.ai.inference.ChatCompletionsClientBuilder;
import com.azure.ai.inference.models.ChatCompletions;
import com.azure.core.credential.AzureKeyCredential;
import com.azure.core.credential.TokenCredential;
import com.azure.core.exception.HttpResponseException;
import com.azure.core.util.logging.ClientLogger;
import com.azure.identity.DefaultAzureCredentialBuilder;
String prompt = "What best practices should I follow when asking an AI model to review Java code?";
String endpoint = "https://<resource-name>.services.ai.azure.com/api/projects/<project-name>";
TokenCredential credential = new DefaultAzureCredentialBuilder().build();
ChatCompletionsClient client = new ChatCompletionsClientBuilder()
.credential(credential)
.endpoint(endpoint)
.buildClient();
```**Create and use an OpenAI-compatible client from your project:**
```java
ChatCompletions completions = client.complete(prompt);
String content = completions.getChoice().getMessage().getContent();
System.out.println("\nResponse from AI assistant:\n" + content);
Créer un client project :
const endpoint = "https://<resource-name>.services.ai.azure.com/api/projects/<project-name>";
const deployment = "gpt-4o";
const project = new AIProjectClient(endpoint, new DefaultAzureCredential());
Créer un client compatible OpenAI à partir de votre project :
const client = await project.getAzureOpenAIClient({
// The API version should match the version of the Azure OpenAI resource
apiVersion: "2024-12-01-preview"
});
const chatCompletion = await client.chat.completions.create({
model: deployment,
messages: [
{ role: "system", content: "You are a helpful assistant" },
{ role: "user", content: "What is the speed of light?" },
],
});
console.log(chatCompletion.choices[0].message.content);
Créer un client project :
string endpoint = "https://<resource-name>.services.ai.azure.com/api/projects/<project-name>";
AIProjectClient projectClient = new AIProjectClient(new Uri(endpoint), new DefaultAzureCredential());
Créer un client compatible OpenAI à partir de votre project :
ClientConnection connection = projectClient.GetConnection(typeof(AzureOpenAIClient).FullName!);
if (!connection.TryGetLocatorAsUri(out Uri uri) || uri is null)
{
throw new InvalidOperationException("Invalid URI.");
}
uri = new Uri($"https://{uri.Host}");
const string modelDeploymentName = "gpt-4o";
AzureOpenAIClient azureOpenAIClient = new AzureOpenAIClient(uri, new DefaultAzureCredential());
ChatClient chatClient = azureOpenAIClient.GetChatClient(deploymentName: modelDeploymentName);
Console.WriteLine("Complete a chat");
ChatCompletion result = chatClient.CompleteChat("List all the rainbow colors");
Console.WriteLine(result.Content[0].Text);
Ce que vous pouvez faire avec le Kit de développement logiciel (SDK) Foundry
- Les modèles de Access Foundry, y compris ceux d'Azure OpenAI
- Utilisez le service de l’Agent Foundry
- Exécuter des évaluations cloud
- Activer le suivi des applications
- Affiner un modèle
- Obtenez les points de terminaison et les clés pour Foundry Tools, l’orchestration locale et bien plus encore
Résolution des problèmes
Erreurs d’authentification
Si vous voyez DefaultAzureCredential failed to retrieve a token:
Verify Azure CLI est authentifié :
az account show az login # if not logged inVérifiez l’attribution de rôle RBAC :
- Vérifiez que vous avez au moins le rôle d’utilisateur IA Azure sur le project Foundry
- Consultez Assigner des rôles Azure
Pour l’identité managée en production :
- Vérifiez que l’identité managée a le rôle approprié attribué
- Voir Configurer des identités managées
Erreurs de configuration de point de terminaison
Si vous voyez Connection refused ou 404 Not Found:
- Vérifiez que les noms de ressources et de projets correspondent à votre déploiement réel
-
Check endpoint URL format : doit être
https://<resource-name>.services.ai.azure.com/api/projects/<project-name> -
Pour les sous-domaines personnalisés : remplacer
<resource-name>par votre sous-domaine personnalisé
Incompatibilités de version du Kit de développement logiciel (SDK)
Si des exemples de code échouent avec AttributeError ou ModuleNotFoundError:
-
Vérifiez la version du Kit de développement logiciel (SDK) :
pip show azure-ai-projects # Python npm list @azure/ai-projects # JavaScript dotnet list package # .NET - Vérifier l’alignement de moniker : le SDK 2.x nécessite le portail Foundry, le KIT SDK 1.x nécessite Foundry Classic
- Réinstaller avec des indicateurs de version corrects : consultez les commandes d’installation dans chaque section de langue ci-dessus
Kit de développement logiciel (SDK) OpenAI
Utilisez le Kit de développement logiciel (SDK) OpenAI lorsque vous souhaitez accéder à l'ensemble des fonctionnalités de l'API OpenAI et à la compatibilité maximale avec les clients. Ce point de terminaison permet d’accéder aux modèles Azure OpenAI et aux modèles Foundry directs (via l’API Chat Completions). Il ne fournit pas d'accès aux fonctionnalités spécifiques à Foundry telles que les agents et les évaluations.
L’extrait de code suivant montre comment utiliser directement le point de terminaison Azure OpenAI /openai/v1.
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-name>.openai.azure.com/openai/v1/",
api_key=token_provider,
)
response = client.responses.create(
model="model_deployment_name",
input= "What is the size of France in square miles?"
)
print(response.model_dump_json(indent=2))
Pour plus d’informations, consultez Langages de programmation Azure pris en charge par OpenAI. Sortie attendue :
{
"id": "resp_abc123",
"object": "response",
"created": 1234567890,
"model": "gpt-5.2",
"output_text": "France has an area of approximately 213,011 square miles (551,695 square kilometers)."
}
Pour plus d’informations, consultez les langages de programmation pris en charge par Azure OpenAI
Important
Les éléments marqués (aperçu) dans cet article sont actuellement en aperçu public. Cette version préliminaire est fournie sans contrat de niveau de service, et nous la déconseillons pour les charges de travail en production. Certaines fonctionnalités peuvent être limitées ou non prises en charge. Pour plus d’informations, consultez les Conditions d’utilisation Complémentaires de Microsoft Azure Previews.
L’extrait de code suivant montre comment utiliser directement le point de terminaison Azure OpenAI /openai/v1.
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.core.credential.AzureKeyCredential;
import com.azure.core.util.Configuration;
import java.util.ArrayList;
import java.util.List;
String endpoint = "https://<resource-name>.openai.azure.com/openai/v1";
String deploymentName = "gpt-5.2";
TokenCredential defaultCredential = new DefaultAzureCredentialBuilder().build();
OpenAIClient client = new OpenAIClientBuilder()
.credential(defaultCredential)
.endpoint("{endpoint}")
.buildClient();
List<ChatRequestMessage> chatMessages = new ArrayList<>();
chatMessages.add(new ChatRequestSystemMessage("You are a helpful assistant."));
chatMessages.add(new ChatRequestUserMessage("What is the speed of light?"));
ChatCompletions chatCompletions = client.getChatCompletions(deploymentName, 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());
Pour plus d’informations sur l’utilisation du Kit de développement logiciel (SDK) OpenAI, consultez Azure langages de programmation pris en charge par OpenAI.
import { AzureOpenAI } from "openai";
import { DefaultAzureCredential } from "@azure/identity";
const deployment = "gpt-4o"
const endpoint = "https://<resource-name>.openai.azure.com/openai/v1";
const scope = "https://ai.azure.com/.default";
const apiVersion = "2024-04-01-preview";
const azureADTokenProvider = getBearerTokenProvider(new DefaultAzureCredential(), scope);
const options = { azureADTokenProvider, deployment, apiVersion }
const client = new AzureOpenAI(options);
const result = await client.chat.completions.create({
model: deployment,
messages: [
{ role: "system", content: "You are a helpful assistant" },
{ role: "user", content: "What is the speed of light?" },
],
});
console.log(result.choices[0].message.content);
Pour plus d’informations sur l’utilisation du Kit de développement logiciel (SDK) OpenAI, consultez Azure langages de programmation pris en charge par OpenAI.
- Installez le package OpenAI : exécutez cette commande pour ajouter la bibliothèque de client OpenAI à votre .NET project.
dotnet add package OpenAI ```When it succeeds, the .NET CLI confirms that it installed the `OpenAI` package. This snippet configures `DefaultAzureCredential`, builds `OpenAIClientOptions`, and creates a `ChatClient` for the Azure OpenAI v1 endpoint. ```csharp using System.ClientModel.Primitives; using Azure.Identity; using OpenAI; using OpenAI.Chat; #pragma warning disable OPENAI001 const string directModelEndpoint = "https://<resource-name>.openai.azure.com/openai/v1/"; const string modelDeploymentName = "gpt-5.2"; BearerTokenPolicy tokenPolicy = new( new DefaultAzureCredential(), "https://ai.azure.com/.default"); OpenAIClient openAIClient = new( authenticationPolicy: tokenPolicy, options: new OpenAIClientOptions() { Endpoint = new($"{directModelEndpoint}"), }); ChatClient chatClient = openAIClient.GetChatClient(modelDeploymentName); ChatCompletion completion = await chatClient.CompleteChatAsync( [ new SystemChatMessage("You are a helpful assistant."), new UserChatMessage("How many feet are in a mile?") ]); Console.WriteLine(completion.Content[0].Text); #pragma warning restore OPENAI001
Pour plus d’informations sur l’utilisation du Kit de développement logiciel (SDK) OpenAI, consultez Azure langages de programmation pris en charge par OpenAI.
Utilisation de l’infrastructure agent pour l’orchestration locale
Microsoft Agent Framework est un Kit de développement logiciel (SDK) open source permettant de créer des systèmes multi-agents dans du code (par exemple, .NET et Python) avec une interface indépendante du fournisseur de cloud.
Utilisez Agent Framework lorsque vous souhaitez définir et orchestrer des agents localement. Associez-le au Kit de développement logiciel (SDK) Foundry lorsque vous souhaitez que ces agents s’exécutent sur des modèles Foundry ou lorsque vous souhaitez que Agent Framework orchestre les agents hébergés dans Foundry.
Pour plus d’informations, consultez la vue d’ensemble de Microsoft Agent Framework.
Outils de fonderie SDKs
Les outils Foundry (anciennement Azure AI Services) sont des solutions prêtes à l’emploi avec des SDK dédiés. Utilisez les points de terminaison suivants pour utiliser Foundry Tools.
Quel point de terminaison devez-vous utiliser ?
Choisissez un point de terminaison en fonction de vos besoins :
Utilisez le point de terminaison Azure AI Services pour accéder à Computer Vision, la sécurité du contenu, l'intelligence des documents, la langue, la traduction et les outils de recherche de jetons.
Point de terminaison Outils de fonderie : https://<your-resource-name>.cognitiveservices.azure.com/
Note
Les points de terminaison utilisent votre nom de ressource ou un sous-domaine personnalisé. Si votre organisation a configuré un sous-domaine personnalisé, remplacez your-resource-name par your-custom-subdomain dans tous les exemples de point de terminaison.
Pour Foundry Tools reconnaissance vocale et de traduction, utilisez les points de terminaison dans les tableaux suivants. Remplacez les espaces réservés par vos informations sur la ressource.
Points de terminaison du service Speech
| Outil de Fonderie | Point de terminaison |
|---|---|
| Reconnaissance vocale (standard) | https://<YOUR-RESOURCE-REGION>.stt.speech.microsoft.com |
| Text to Speech (neuronal) | https://<YOUR-RESOURCE-REGION>.tts.speech.microsoft.com |
| Custom Voice | https://<YOUR-RESOURCE-NAME>.cognitiveservices.azure.com/ |
Points d'accès de traduction
| Outil de Fonderie | Point de terminaison |
|---|---|
| Traduction de texte | https://api.cognitive.microsofttranslator.com/ |
| Traduction de documents | https://<YOUR-RESOURCE-NAME>.cognitiveservices.azure.com/ |
Les sections suivantes incluent des liens de démarrage rapide pour les kits SDK Foundry Tools et les informations de référence.
