Sofortmodelle in Microsoft Foundry (Vorschau)

Mit Sofortmodellen können Sie jedes unterstützte Modell anhand des Namens aufrufen – keine Bereitstellung erforderlich. Erstellen Sie ein Foundry-Projekt, beginnen Sie mit dem Codieren und verwenden Sie jedes verfügbare Modell sofort.

Voraussetzungen

• Ein Azure-Abonnement. Erstellen Sie ein kostenloses Konto.
• Melden Sie sich bei Microsoft Foundry an. Stellen Sie sicher, dass die Umschaltfläche "Neue Gießerei " aktiviert ist. Diese Schritte beziehen sich auf Foundry (neu).
• Ein Foundry-Projekt in West US 3 (die einzige unterstützte Region für Sofortmodelle während der Vorschau). Wenn Sie ein Projekt erstellen müssen, lesen Sie "Erstellen eines Projekts".
• Die Rolle „Foundry User“ im Projekt oder Konto.

Important

Die Foundry-RBAC-Rollen wurden kürzlich umbenannt. Foundry User, Foundry Owner, Foundry Account Owner und Foundry Project Manager wurden zuvor Azure KI-Benutzer, Azure KI-Besitzer, Azure KI-Kontobesitzer und Azure AI Project Manager benannt. Möglicherweise werden die vorherigen Namen an einigen Stellen weiterhin angezeigt, während der Umbenennungsrollout ausgeführt wird. Die Rollen-IDs und Kernberechtigungen bleiben durch die Umbenennung unverändert.

Beginnen Sie sofort mit der Verwendung von Modellen

Bei Sofortmodellen ist der Workflow einfach – verwenden Sie einen unterstützten Sofortmodellnamen in Ihrem Code. Es ist keine Bereitstellung erforderlich. Die gleiche API, das SDK und der Client, die Sie bereits für Bereitstellungen verwenden, funktioniert mit Sofortmodellen. Kein zweites SDK, kein separater Client, keine Konfigurationsänderungen.

Python

Die einzige Änderung aus dem bereitstellungsbasierten Code ist der model Parameter. Ersetzen Sie im folgenden Code "gpt-5-mini" durch den Namen eines beliebigen Sofortmodells.

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

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

# 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="gpt-5-mini",
    input="What is the size of France in square miles?",
)
print(f"Response output: {response.output_text}")

C#

Die einzige Änderung aus dem bereitstellungsbasierten Code ist der model Parameter. Ersetzen Sie im folgenden Code "gpt-5-mini" durch den Namen eines beliebigen Sofortmodells.

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 = "your_project_endpoint";

// 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("gpt-5-mini"); 
ResponseResult response = await responseClient.CreateResponseAsync(
    "What is the size of France in square miles?");
Console.WriteLine(response.GetOutputText());

TypeScript

Die einzige Änderung aus dem bereitstellungsbasierten Code ist der model Parameter. Ersetzen Sie im folgenden Code "gpt-5-mini" durch den Namen eines beliebigen Sofortmodells.

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);

Java

Die einzige Änderung aus dem bereitstellungsbasierten Code ist der model Parameter. Ersetzen Sie im folgenden Code "gpt-5-mini" durch den Namen eines beliebigen Sofortmodells.

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());
    }
}

REST-API

Die einzige Änderung aus dem bereitstellungsbasierten Code ist der model Parameter. Ersetzen Sie im folgenden Code "gpt-5-mini" durch den Namen eines beliebigen Sofortmodells. Ersetzen Sie YOUR-FOUNDRY-RESOURCE-NAME außerdem durch Ihre Werte:

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.1-mini",
        "input": "What is the size of France in square miles?"
}'

Gießereiportal

1. Wählen Sie auf der Startseite Ihres Projekts " Im Playground testen" aus. (Dies kann stattdessen als "Erkunden von Spielplätzen" bezeichnet werden).

2. Verwenden Sie im Playground das Dropdown-Menü „Modell“, um zwischen bereitgestellten Modellen und Instant-Modellen zu wechseln.

Warum Sofortmodelle wichtig sind

• Wechseln Sie modelle, indem Sie eine Zeichenfolge ändern – verwenden Sie einen beliebigen Sofortmodellnamen in der model= Zeile, ohne Bereitstellungen zu erstellen oder zu löschen.
• Dieselbe API und das GLEICHE SDK – die gleichen Aufrufe funktionieren sowohl für Sofortmodelle als auch für Bereitstellungen.
• Arbeitet mit Ihren Entwicklungstools zusammen – Sofortmodelle sind in Foundry CLI-, VS-Code- und CI/CD-Pipelines auf die gleiche Weise wie Bereitstellungen integriert.

Bereitstellungen werden nicht verschwinden. Sie bleiben die richtige Wahl, wenn Sie reservierten Durchsatz, benutzerdefinierte Inhaltsfilter, Data Residency oder erweiterte Unternehmenskonfigurationen benötigen. Sofortmodelle vereinfachen den Einstieg, sodass Bereitstellungen etwas sind, zu dem Sie erst später übergehen – und keine Hürde, die Sie nehmen müssen, bevor Sie ein Modell verwenden können.

Unterstützte Modelle

Neue Modelle unterstützen den sofortigen Zugriff standardmäßig, wenn sie freigegeben werden. Die Unterstützung für zusätzliche Modelle wird basierend auf der Kundennachfrage berücksichtigt.

Alle Modelle mit Sofortzugriff anzeigen:

1. Öffnen Sie ein Projekt in West US 3 in der neuen Foundry-Erfahrung,
2. Wählen Sie " Entdecken" in der oberen rechten Navigation und dann " Modelle " im linken Bereich aus.
3. Wählen Sie im Modellkatalog " Sofort " unter " Entwicklungsoptionen " aus, um die verfügbaren Sofortmodelle anzuzeigen.

Sie können auch Sofortmodelle programmatisch auflisten:

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

Note

Während der Vorschau sind Instant-Modelle nur für Projekte in West US 3 verfügbar.

Einige Sofortmodelle werden möglicherweise in der Liste angezeigt, auch wenn Ihr Abonnement kein Kontingent für sie hat. Weitere Informationen finden Sie unter "Kontingente und Grenzwerte für Gießereimodelle".

Wann Instant-Modelle gegenüber Bereitstellungen verwendet werden sollten

Szenario	Empfohlener Ansatz
Erste Schritte, Prototyperstellung oder Experimentierung	Modelle für Sofortantworten
Verwenden des neuesten Modells unmittelbar nach der Veröffentlichung	Modelle für Sofortantworten
Erforderliche reservierte Kapazität oder vorhersehbarer Durchsatz	Einsatz
Erfordert bereitgestellten Durchsatz (PTU)	Einsatz
Benötigen Sie Datenresidenz in einer bestimmten Region	Einsatz
Benutzerdefinierte Inhaltsfilterrichtlinien pro Modell	Einsatz
Benutzerdefinierte Schutzläufe pro Modell	Einsatz
Endpunktspezifische Konfiguration (z. B. Versionssperrungen pro Endpunkt)	Einsatz
Feingranulare Kontingentaufteilung über Teams hinweg	Einsatz
Fein abgestimmte Modelle	Einsatz

Sofortmodelle und Bereitstellungen können im selben Projekt koexistieren. Sie können mit Sofortmodellen beginnen und später Bereitstellungen erstellen, sobald sich Ihre Anforderungen weiterentwickeln.

Modellversionen

Standardmäßig werden Instant-Modelle an die neueste Evergreen-Version eines Modells weitergeleitet. Um auf eine bestimmte Version festzulegen, hängen Sie das Versionsdatum als Suffix mit Bindestrich an den Modellnamen an:

Was Sie als model übergeben	Behavior
model-name	Leitet zur aktuellsten Version weiter
model-name-2025-04-01	Weiterleitung zu dieser spezifischen Version

Die Versionsfixierung muss explizit aktiviert werden. Wenn Ihre Anwendung Stabilität erfordert, schließen Sie das Versionssuffix ein. Andernfalls erhalten Sie immer die neueste Version automatisch.

Wie Kontingent verbraucht wird

Sofortmodelle greifen auf einen pro Modell geltenden globalen Kontingentpool zu, der Ihrem Abonnement zugewiesen ist. Dieses Kontingent ist von dem regionalen Kontingent getrennt, das für Standardbereitstellungen verwendet wird.

• Sie weisen kein globales Kontingent zu und teilen es nicht auf – es wird automatisch über alle Nutzungen von Instant-Modellen innerhalb Ihres Abonnements gemeinsam genutzt.
• Globale Standardbereitstellungen reservieren einen Teil Ihres globalen Kontingents. Sofortmodelle verwenden die verbleibenden Kapazitäten.
• Andere Bereitstellungstypen (Regionaler Standard, bereitgestellt) verwenden ein separates regionales Kontingent und wirken sich nicht auf die Kapazität des Sofortmodells aus.
• Wenn Sofortmodellanforderungen gedrosselt werden, können Sie eine Kontingenterhöhung anfordern oder eine Bereitstellung mit reservierter Kapazität erstellen.

Weitere Informationen dazu, wie globale und regionale Kontingente interagieren, finden Sie unter Verwalten und Erhöhen von Kontingenten.

Unternehmenssteuerungen

Fähigkeit	So funktioniert es
Blockieren bestimmter Modelle oder Anbieter	Azure Policy Definitionen gelten für Sofortmodelle auf die gleiche Weise wie für Bereitstellungen.
An eine Modellversion anheften	Fügen Sie das Versionssuffix an den Modellnamen an (siehe Modellversionen)
Vollständiges Deaktivieren von Sofortmodellen	Administratoren können Sofortmodelle auf Abonnementebene über Azure Policy deaktivieren.

Um Sofortmodelle aus einem Konto zu entfernen, konfigurieren Sie die Einstellungen über Bicep oder ARM REST.

REST-API

Aktualisieren Sie Ihr Konto mit:

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

Verwenden Sie diesen Anforderungstext, um den sofortigen Modellzugriff effektiv zu beenden:

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

Bicep

Aktualisieren Sie Ihre bestehende Account-Ressource mit einem instant-Block:

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: []
    }
  }
}

Important

Alle Instant-Modelle verwenden standardmäßig Sicherheitsvorkehrungen und Inhaltsfilter. Sie können jedoch für Sofortmodelle keine benutzerdefinierten Schutzmechanismen oder Responsible AI (RAI)-Richtlinien für jedes Modell einzeln konfigurieren. Sie können eine RAI-Standardrichtlinie auf Kontoebene über die API festlegen, diese Richtlinie gilt jedoch einheitlich für alle Sofortmodelle. Wenn Sie unterschiedliche Inhaltsfilterrichtlinien für einzelne Modelle benötigen, verwenden Sie eine Bereitstellung.

Kollisionen mit Bereitstellungsnamen

Neue Bereitstellungen können keinen Namen verwenden, der einem vorhandenen Modellnamen entspricht. Wenn Sie über eine vorhandene Bereitstellung verfügen, deren Name mit einem Modellnamen kollidiert, hat die Bereitstellung Vorrang und sofortiger Modellzugriff für diesen Modellnamen ist in diesem Projekt nicht verfügbar.

Einschränkungen während der Vorschau

• Nur in West-US 3 verfügbar.
• Feinabgestimmte Modelle werden nicht unterstützt. Um ein fein abgestimmtes Modell zu verwenden, erstellen Sie eine Bereitstellung.
• Guardrails, benutzerdefinierte RAI-Richtlinien und Inhaltsfilter sind für Sofortmodelle nicht konfigurierbar.
• Nur die in unterstützten Modellen aufgeführten Modelle sind berechtigt.

Verwandte Inhalte

• Übersicht über die Bereitstellung von Foundry-Modellen von Microsoft
• Deployment-Typen für Microsoft Foundry Models
• Verwalten von Kontingenten für Foundry-Ressourcen
• Microsoft Foundry – Schnellstart