Accès instantané aux modèles dans Microsoft Foundry (préversion)

L’accès instantané aux modèles vous permet d’appeler n’importe quel modèle pris en charge par nom , aucun déploiement n’est requis. Créez un projet Foundry, commencez à coder et utilisez immédiatement n’importe quel modèle disponible.

Prerequisites

• Un abonnement Azure. Créez-en un gratuitement.
• Connectez-vous à Microsoft Foundry. Vérifiez que l'option New Foundry est activée. Ces étapes font référence à Foundry (nouveau).
• Un projet Foundry dans la région USA Ouest 3 (la seule région prise en charge pour l’accès instantané pendant la version préliminaire). Si vous devez créer un projet, consultez Créer un projet.
• Rôle Utilisateur Foundry sur le projet ou le compte.

Commencer à utiliser des modèles instantanément

Avec l’accès instantané, le flux de travail est simple : utilisez un nom de modèle instantané pris en charge dans votre code. Aucun déploiement n’est nécessaire. La même API, le SDK et le client que vous utilisez déjà pour les déploiements fonctionnent avec des modèles d’accès instantané. Aucun deuxième SDK, aucun client distinct, aucune modification de configuration.

La prise en charge de l’accès instantané continue de s’étendre au fil du temps. L'ensemble exact change fréquemment. Consultez les modèles pris en charge pour voir la liste complète.

import os

from azure.identity import DefaultAzureCredential
from azure.ai.projects import AIProjectClient

# Format: "https://resource_name.ai.azure.com/api/projects/project_name"
PROJECT_ENDPOINT = os.getenv("AZURE_AI_PROJECT_ENDPOINT", "your_project_endpoint")
MODEL_DEPLOYMENT = os.getenv("MODEL_DEPLOYMENT", "gpt-5-mini")

# Create project and openai clients to call Foundry API
project = AIProjectClient(
    endpoint=PROJECT_ENDPOINT,
    credential=DefaultAzureCredential(),
)
openai = project.get_openai_client()

# Run a responses API call
response = openai.responses.create(
    model=MODEL_DEPLOYMENT,
    input="What is the size of France in square miles?",
)
if not response.output_text or not response.output_text.strip():
    raise RuntimeError("Response output text was empty.")

print(f"Response output: {response.output_text}")

using Azure.Identity;
using Azure.AI.Projects;
using Azure.AI.Extensions.OpenAI;
using OpenAI.Responses;

#pragma warning disable OPENAI001

// Format: "https://resource_name.ai.azure.com/api/projects/project_name"
var projectEndpoint = Environment.GetEnvironmentVariable("AZURE_AI_PROJECT_ENDPOINT") ?? "your_project_endpoint";
var modelDeployment = Environment.GetEnvironmentVariable("MODEL_DEPLOYMENT") ?? "gpt-5-mini";

// Create project client to call Foundry API
AIProjectClient projectClient = new(
    endpoint: new Uri(projectEndpoint),
    tokenProvider: new DefaultAzureCredential());

// Run a responses API call
ProjectResponsesClient responseClient = projectClient.ProjectOpenAIClient.GetProjectResponsesClientForModel(modelDeployment);
ResponseResult response = await responseClient.CreateResponseAsync(
    "What is the size of France in square miles?");
string outputText = response.GetOutputText();
if (string.IsNullOrWhiteSpace(outputText))
{
    throw new InvalidOperationException("Response output text was empty.");
}

Console.WriteLine(outputText);

import { DefaultAzureCredential } from "@azure/identity";
import { AIProjectClient } from "@azure/ai-projects";

// Format: "https://resource_name.ai.azure.com/api/projects/project_name"
const PROJECT_ENDPOINT = "your_project_endpoint";

async function main(): Promise<void> {
    // Create project and openai clients to call Foundry API
    const project = new AIProjectClient(PROJECT_ENDPOINT, new DefaultAzureCredential());
    const openai = project.getOpenAIClient();

    // Run a responses API call
    const response = await openai.responses.create({
        model: "gpt-5-mini",
        input: "What is the size of France in square miles?",
    });
    console.log(`Response output: ${response.output_text}`);
}

main().catch(console.error);

package com.azure.ai.agents;

import com.azure.identity.DefaultAzureCredentialBuilder;
import com.openai.models.responses.Response;
import com.openai.models.responses.ResponseCreateParams;

public class CreateResponse {
    public static void main(String[] args) {
        // Format: "https://resource_name.ai.azure.com/api/projects/project_name"
        String ProjectEndpoint = "your_project_endpoint";

        // Create responses client to call Foundry API
        ResponsesClient responsesClient = new AgentsClientBuilder()
                .credential(new DefaultAzureCredentialBuilder().build())
                .endpoint(ProjectEndpoint)
                .buildResponsesClient();

        // Run a responses API call
        ResponseCreateParams responseRequest = new ResponseCreateParams.Builder()
                .input("What is the size of France in square miles?")
                .model("gpt-5-mini")
                .build();
        Response response = responsesClient.getResponseService().create(responseRequest);
        System.out.println(response.output());
    }
}

curl -X POST https://YOUR-FOUNDRY-RESOURCE-NAME.services.ai.azure.com/api/projects/YOUR-PROJECT-NAME/openai/v1/responses \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $AZURE_AI_AUTH_TOKEN" \
-d '{
        "model": "gpt-5-mini",
        "input": "What is the size of France in square miles?"
}'

Espace de test pour les modèles à accès instantané

Pour atteindre le terrain de jeu pour les modèles d’accès instantané, utilisez l’un des chemins suivants :

1. Depuis Home, sélectionnez Test in playground.
2. À partir de la page d’accueil, sélectionnez Explorer les modèles pour accéder au catalogue de modèles. Vous pouvez également sélectionner Découvrir des>modèles. L’un ou l’autre chemin ouvre le catalogue.
3. Dans le catalogue de modèles, sélectionnez un modèle d’accès instantané pour afficher ses détails.
4. Dans une page de détails du modèle d’accès instantané, sélectionnez Ouvrir le terrain de jeu.
5. À partir d’un terrain de jeu, utilisez la liste déroulante Model pour basculer vers d’autres modèles d’accès instantané ou de déploiement.

Pourquoi l’accès instantané importe

• Changer de modèle en modifiant une chaîne : utilisez n’importe quel nom de modèle instantané dans la model= ligne, sans créer ou supprimer des déploiements.
• Même API et sdk : les mêmes appels fonctionnent à la fois pour l’accès instantané et les déploiements.
• Fonctionne avec vos outils de développement — Accès instantané s’intègre à Foundry CLI, à VS Code et aux pipelines CI/CD comme le font les déploiements.

Les déploiements ne vont pas disparaître. Ils restent le bon choix lorsque vous avez besoin d’un débit réservé, de filtres de contenu personnalisés, de résidence de données ou de configurations d’entreprise avancées. L’accès instantané simplifie l’expérience de démarrage, de sorte que les déploiements deviennent une étape à laquelle on accède progressivement, et non un obstacle à franchir avant de pouvoir utiliser un modèle.

Modèles pris en charge

Les nouveaux modèles prennent en charge l’accès instantané par défaut lorsqu’ils sont libérés. L’équipe produit prend en charge des modèles supplémentaires en fonction de la demande du client. La liste augmente au fil du temps et des exemples de modèles que vous pouvez voir sont les suivants :

• chat-gpt-latest
• gpt-5.6-sol
• gpt-5.5
• gpt-5-mini
• gpt-5.3-codex

Pour afficher tous les modèles qui prennent en charge l’accès instantané :

1. Ouvrez un projet dans West US 3 dans la nouvelle expérience Foundry,
2. Sélectionnez Découvrir dans le volet supérieur droit, puis Modèles dans le volet gauche.
3. Dans le catalogue de modèles, sélectionnez Instantané sous Options de déploiement pour afficher les modèles d’accès instantané disponibles.

Vous pouvez également répertorier les modèles d’accès instantané par programmation :

SUBSCRIPTION_ID="<your-subscription-id>"
LOCATION="westus3"

az rest --method get \
  --url "https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/providers/Microsoft.CognitiveServices/locations/$LOCATION/models?api-version=2025-06-01" \
  --output json \
| jq -r '(.value // .models // .)[]
  | select((.model.capabilities.instant // "false" | tostring | ascii_downcase) == "true")
  | .model.name' \
| sort -u

Quand utiliser l’accès instantané et les déploiements

L’accès instantané et les déploiements peuvent coexister dans le même projet. Vous pouvez commencer par un modèle d’accès instantané et créer un déploiement ultérieurement à mesure que vos besoins évoluent.

Versions du modèle

Par défaut, l’accès instantané utilise la dernière version persistante d’un modèle. Pour épingler sur une version spécifique, ajoutez la date de la version au nom du modèle sous forme de suffixe précédé d’un trait d’union :

L’épinglage de version est facultatif. Si votre application nécessite une stabilité, incluez le suffixe de version. Sinon, vous obtenez toujours la dernière version automatiquement.

Utilisation du quota

L’accès instantané s’appuie sur une réserve de quota globale, propre à chaque modèle, attribuée à votre abonnement. Ce quota est distinct du quota régional utilisé par les déploiements standard.

• Vous n’allouez ni ne répartissez de quota global : il est automatiquement partagé entre toutes les utilisations des modèles instantanés couvertes par votre abonnement.
• Les déploiements globaux Standard réservent une partie de votre quota global. Les modèles d’accès instantané utilisent la capacité restante.
• D’autres types de déploiement (Standard régional, Provisionné) utilisent un quota régional distinct et n’affectent pas la capacité de votre modèle instantané.
• Si les demandes de modèle instantané sont limitées, vous pouvez demander une augmentation du quota ou créer un déploiement avec une capacité réservée.

Pour plus d’informations sur la façon dont les quotas globaux et régionaux interagissent, consultez Gérer et augmenter les quotas.

Contrôles pour les entreprises

Pour supprimer l’accès instantané d’un compte, configurez les paramètres via Bicep ou ARM REST.

PATCH https://management.azure.com/subscriptions/{sub}/resourceGroups/{rg}/providers/Microsoft.CognitiveServices/accounts/{account}?api-version=2026-01-15-preview
Authorization: Bearer {arm_token}
Content-Type: application/json

{
  "properties": {
    "instant": {
      "raiPolicyName": "Microsoft.DefaultV2",
      "modelAllowList": []
    }
  }
}

resource account 'Microsoft.CognitiveServices/accounts@2026-01-15-preview' = {
  name: accountName
  location: location
  kind: 'AIServices'
  sku: {
    name: 'S0'
  }
  // Keep your existing account properties and add instant settings.
  properties: {
    instant: {
      raiPolicyName: 'Microsoft.DefaultV2'
      modelAllowList: []
    }
  }
}

Collisions de noms de déploiement

Les nouveaux déploiements ne peuvent pas utiliser de nom qui correspond à un nom de modèle existant. Si vous disposez d’un déploiement existant dont le nom entre en conflit avec un nom de modèle, le déploiement est prioritaire et l’accès instantané au modèle pour ce nom de modèle n’est pas disponible dans ce projet.

Limitations pendant l'aperçu

• Disponible uniquement dans West US 3.
• Les modèles affinés ne sont pas pris en charge. Pour utiliser un modèle affiné, créez un déploiement.
• Les garde-fous, les stratégies RAI personnalisées et les filtres de contenu ne sont pas configurables pour l’accès instantané.
• Seuls les modèles répertoriés dans les modèles pris en charge sont éligibles.

Contenu connexe

• Vue d’ensemble du déploiement pour les modèles Microsoft Foundry
• Types de déploiement pour les modèles Microsoft Foundry
• Gérer les quotas pour les ressources Foundry
• Démarrage rapide de Microsoft Foundry