Erste Schritte mit Azure OpenAI und der Antwort-API

In diesem Artikel erfahren Sie, wie Sie das Azure OpenAI Starter Kit verwenden, um eine Azure OpenAI-Ressource bereitzustellen und eine kleine Hello World-App auszuführen. Die App verwendet Microsoft Entra ID Authentifizierung und das OpenAI SDK, um die Azure OpenAI-Antwort-API aufzurufen.

Am Ende dieses Artikels werden Sie:

  • Stellen Sie Azure OpenAI mit GPT-5-mini mithilfe der Azure Developer CLI bereit.
  • Führen Sie eine lokale App aus, die sich mit Microsoft Entra ID anstelle eines API-Schlüssels authentifiziert.
  • Senden Sie eine Anforderung an die Antwort-API, und drucken Sie die Modellausgabe.

Notiz

In diesem Artikel wird das Azure OpenAI Starter Kit als Grundlage für die Beispiele verwendet. Das Starter Kit enthält Infrastruktur als Code, Azure Developer CLI-Konfiguration und Clientbeispiele für mehrere Programmiersprachen.

Cost

Azure ressourcen, die in diesem Artikel erstellt wurden, werden Ihrem Azure-Abonnement in Rechnung gestellt. Um laufende Gebühren zu vermeiden, bereinigen Sie die Ressourcen, wenn Sie den Artikel fertig stellen.

Voraussetzungen

Um diesen Artikel abzuschließen, benötigen Sie Folgendes:

  • Python 3.8 oder höher.
  • .NET SDK 10 oder höher. Das Starter Kit verwendet dateibasierte C#-Apps mit Paketdirektiven.
  • Node.js 18 oder höher.
  • Wechseln Sie zu 1.25.1 oder höher.
  • Java 21 oder höher.
  • Maven 3.9 oder höher.

Code abrufen

Klonen Sie das Azure OpenAI Starter Kit-Repository, und öffnen Sie den Projektordner.

git clone https://github.com/Azure-Samples/azure-openai-starter.git
cd azure-openai-starter

Anmelden bei Azure

Melden Sie sich mit der Azure CLI und der Azure Developer CLI an.

az login
azd auth login

Wenn Ihr Konto Zugriff auf mehrere Mandanten hat, vergewissern Sie sich, dass der aktive Mandant der Mandant ist, in dem Sie die Ressourcen bereitstellen möchten.

az account show --query tenantId -o tsv

Bereitstellen von Azure OpenAI

Führen Sie den folgenden Azure Developer CLI-Befehl aus dem Repositorystamm aus:

azd up

Verwenden Sie die folgenden Anleitungen, um die Eingabeaufforderungen zu beantworten:

Prompt Antwort
Umgebungsname Verwenden Sie einen kurzen, kleingeschriebenen Namen, wie aoai-hello. Der Wert wird in Azure Ressourcennamen verwendet.
Subscription Wählen Sie das Abonnement aus, in dem Sie die Ressourcen erstellen möchten.
Ort Wählen Sie eine Region in Ihrer Nähe.
Standort des Azure OpenAI-Modells Wählen Sie eine Region aus, in der GPT-5-mini verfügbar ist.

Die Bereitstellung dauert in der Regel mehrere Minuten. Nach Abschluss des Befehls hat das Starterkit Azure OpenAI provisioniert und ein GPT-5-mini-Modell bereitgestellt.

Konfigurieren Ihrer lokalen Umgebung

Die Hello World-App verwendet Ihre Azure Anmeldung, um ein Microsoft Entra Zugriffstoken abzurufen. Legen Sie den vom OpenAI-Client verwendeten Endpunkt fest.

export AZURE_OPENAI_ENDPOINT=$(azd env get-value AZURE_OPENAI_ENDPOINT)
export AZURE_OPENAI_DEPLOYMENT=$(azd env get-value AZURE_OPENAI_GPT_DEPLOYMENT_NAME)
export AZURE_TENANT_ID=$(az account show --query tenantId -o tsv)

Tip

Azure OpenAI verwendet Bereitstellungsnamen in API-Aufrufen. Das Starterkit gibt den GPT-5-mini-Bereitstellungsnamen als AZURE_OPENAI_GPT_DEPLOYMENT_NAME aus. Dieser Artikel ordnet diesen Wert zu AZURE_OPENAI_DEPLOYMENT , sodass der Code in allen Sprachen identisch ist.

Erstellen und Ausführen der Hello World-App

Erstellen Sie eine Datei mit dem Namen hello_world_entra.py im Ordner src/python.

import os

from azure.identity import DefaultAzureCredential, get_bearer_token_provider
from openai import OpenAI

endpoint = os.environ["AZURE_OPENAI_ENDPOINT"].rstrip("/")
deployment = os.getenv("AZURE_OPENAI_DEPLOYMENT", "gpt-5-mini")

token_provider = get_bearer_token_provider(
    DefaultAzureCredential(),
    "https://cognitiveservices.azure.com/.default",
)

client = OpenAI(
    base_url=f"{endpoint}/openai/v1/",
    api_key=token_provider,
)

response = client.responses.create(
    model=deployment,
    input="Say hello from Azure OpenAI in one sentence.",
    max_output_tokens=300,
)

print(response.output_text)

Installieren Sie die Python Abhängigkeiten, und führen Sie die App aus.

cd src/python
python -m pip install -r requirements.txt
python hello_world_entra.py

Erstellen Sie eine Datei mit dem Namen hello_world_entra.cs im Ordner src/dotnet.

#!/usr/bin/dotnet run
#:package OpenAI@2.9.1
#:package Azure.Identity@1.*

using System;
using System.ClientModel.Primitives;
using Azure.Identity;
using OpenAI;
using OpenAI.Responses;

#pragma warning disable OPENAI001

string endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT")
    ?? throw new InvalidOperationException("Set AZURE_OPENAI_ENDPOINT.");
string deployment = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT")
    ?? "gpt-5-mini";

BearerTokenPolicy tokenPolicy = new(
    new DefaultAzureCredential(),
    "https://cognitiveservices.azure.com/.default");

OpenAIClientOptions options = new()
{
    Endpoint = new Uri($"{endpoint.TrimEnd('/')}/openai/v1/")
};

ResponsesClient client = new(tokenPolicy, options);

ResponseResult response = await client.CreateResponseAsync(
    deployment,
    "Say hello from Azure OpenAI in one sentence.",
    null);

Console.WriteLine(response.GetOutputText());

Führen Sie die App aus.

cd src/dotnet
dotnet run hello_world_entra.cs

Erstellen Sie eine Datei mit dem Namen hello_world_entra.ts im Ordner src/typescript.

import OpenAI from "openai";
import { DefaultAzureCredential, getBearerTokenProvider } from "@azure/identity";

const endpoint = process.env.AZURE_OPENAI_ENDPOINT;

if (!endpoint) {
  throw new Error("Set AZURE_OPENAI_ENDPOINT.");
}

const deployment = process.env.AZURE_OPENAI_DEPLOYMENT ?? "gpt-5-mini";
const tokenProvider = getBearerTokenProvider(
  new DefaultAzureCredential(),
  "https://cognitiveservices.azure.com/.default"
);

const client = new OpenAI({
  baseURL: `${endpoint.replace(/\/+$/, "")}/openai/v1/`,
  apiKey: tokenProvider as any,
});

const response = await client.responses.create({
  model: deployment,
  input: "Say hello from Azure OpenAI in one sentence.",
  max_output_tokens: 300,
});

console.log(response.output_text);

Installieren Sie die TypeScript-Abhängigkeiten, und führen Sie die App aus.

cd src/typescript
npm install
npx tsx hello_world_entra.ts

Erstellen Sie eine Datei mit dem Namen hello_world_entra.go im Ordner src/go/responses_example_entra.

package main

import (
  "context"
  "fmt"
  "log"
  "net/http"
  "os"
  "strings"

  "github.com/Azure/azure-sdk-for-go/sdk/azcore/policy"
  "github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime"
  "github.com/Azure/azure-sdk-for-go/sdk/azidentity"
  "github.com/openai/openai-go/v3"
  "github.com/openai/openai-go/v3/option"
  "github.com/openai/openai-go/v3/responses"
)

type policyAdapter option.MiddlewareNext

func (adapter policyAdapter) Do(req *policy.Request) (*http.Response, error) {
  return (option.MiddlewareNext)(adapter)(req.Raw())
}

func newClient(endpoint string) openai.Client {
  const scope = "https://cognitiveservices.azure.com/.default"

  credential, err := azidentity.NewDefaultAzureCredential(nil)
  if err != nil {
    log.Fatalf("Failed to create DefaultAzureCredential: %s", err)
  }

  bearerTokenPolicy := runtime.NewBearerTokenPolicy(
    credential,
    []string{scope},
    nil,
  )

  return openai.NewClient(
    option.WithBaseURL(strings.TrimRight(endpoint, "/")+"/openai/v1/"),
    option.WithMiddleware(func(req *http.Request, next option.MiddlewareNext) (*http.Response, error) {
      pipeline := runtime.NewPipeline(
        "aoai-hello-world",
        "",
        runtime.PipelineOptions{},
        &policy.ClientOptions{
          PerRetryPolicies: []policy.Policy{
            bearerTokenPolicy,
            policyAdapter(next),
          },
        },
      )

      pipelineRequest, err := runtime.NewRequestFromRequest(req)
      if err != nil {
        return nil, err
      }

      return pipeline.Do(pipelineRequest)
    }),
  )
}

func main() {
  endpoint := os.Getenv("AZURE_OPENAI_ENDPOINT")
  if endpoint == "" {
    log.Fatal("Set AZURE_OPENAI_ENDPOINT.")
  }

  deployment := os.Getenv("AZURE_OPENAI_DEPLOYMENT")
  if deployment == "" {
    deployment = "gpt-5-mini"
  }

  client := newClient(endpoint)

  response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
    Model: deployment,
    Input: responses.ResponseNewParamsInputUnion{
      OfString: openai.String("Say hello from Azure OpenAI in one sentence."),
    },
    MaxOutputTokens: openai.Int(300),
  })
  if err != nil {
    log.Fatalf("Failed to create response: %s", err)
  }

  fmt.Println(response.OutputText())
}

Führen Sie die App aus.

cd src/go/responses_example_entra
go run hello_world_entra.go

Erstellen Sie eine Datei mit dem Namen HelloWorldEntra.java im Ordner src/java/src/main/java/com/azure/openai/starter.

package com.azure.openai.starter;

import com.azure.identity.AuthenticationUtil;
import com.azure.identity.DefaultAzureCredentialBuilder;
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.credential.BearerTokenCredential;
import com.openai.models.responses.Response;
import com.openai.models.responses.ResponseCreateParams;

import java.util.function.Supplier;

public class HelloWorldEntra {

    public static void main(String[] args) {
        String endpoint = System.getenv("AZURE_OPENAI_ENDPOINT");
        if (endpoint == null || endpoint.isBlank()) {
            throw new IllegalStateException("Set AZURE_OPENAI_ENDPOINT.");
        }

        String deployment = System.getenv().getOrDefault(
                "AZURE_OPENAI_DEPLOYMENT",
                "gpt-5-mini");

        Supplier<String> bearerTokenSupplier = AuthenticationUtil.getBearerTokenSupplier(
                new DefaultAzureCredentialBuilder().build(),
                "https://cognitiveservices.azure.com/.default");

        OpenAIClient client = OpenAIOkHttpClient.builder()
                .baseUrl(endpoint.replaceAll("/+$", "") + "/openai/v1/")
                .credential(BearerTokenCredential.create(bearerTokenSupplier))
                .build();

        Response response = client.responses().create(
                ResponseCreateParams.builder()
                        .model(deployment)
                        .input(ResponseCreateParams.Input.ofText(
                                "Say hello from Azure OpenAI in one sentence."))
                        .maxOutputTokens(300)
                        .build());

        System.out.println(response.output());
    }
}

Führen Sie die App aus.

cd src/java
mvn compile exec:java -Dexec.mainClass="com.azure.openai.starter.HelloWorldEntra"

Das genaue Ausgabeformat variiert je nach SDK. Sie sollten eine Ausgabe des bereitgestellten Azure OpenAI-Modells sehen, die eine kurze Begrüßung enthält.

Hello from Azure OpenAI! I'm running on your Azure OpenAI deployment and ready to help.

Grundlegendes zum Code

Die Hello World-App weist drei wichtige Teile auf:

  • DefaultAzureCredential ruft bei Ihrer lokalen Azure-Anmeldung ein Microsoft Entra-Token ab.
  • Der OpenAI-Client verweist auf Ihren Azure OpenAI v1-Endpunkt: /openai/v1/.
  • Der model Wert ist der Azure OpenAI-Bereitstellungsname. In diesem Starterkit ist der Bereitstellungsname gpt-5-mini.

Die Python App verwendet das openai Paket mit azure-identity. Die get_bearer_token_provider Hilfsfunktion erstellt einen Tokenanbieter, den der OpenAI-Client als Anmeldeinformation verwenden kann.

Die C#-App verwendet das OpenAI Paket mit Azure.Identity. Das BearerTokenPolicy fügt Microsoft Entra-Token zu Anfragen hinzu, die vom ResponsesClient gesendet werden.

Die TypeScript-App verwendet das openai Paket mit @azure/identity. Die getBearerTokenProvider Hilfsfunktion erstellt einen Tokenanbieter, den der OpenAI-Client als Anmeldeinformation verwenden kann.

Die Go-App verwendet azidentity.NewDefaultAzureCredential mit einer Azure Core Bearer-Token-Richtlinie. Die Richtlinie wird als Middleware in den OpenAI-Client eingebunden, sodass Anfragen Microsoft-Entra-ID-Token verwenden.

Die Java-App verwendet DefaultAzureCredentialBuilder mit AuthenticationUtil.getBearerTokenSupplier. Der Tokenanbieter wird dem OpenAI-Client unter Verwendung von BearerTokenCredential übergeben.

Starterkit-Beispiel ausführen

Das Starter Kit enthält auch ein größeres Antwort-API-Beispiel für jede Sprache.

python responses_example_entra.py

dotnet run responses_example_entra.cs

npx tsx responses_example_entra.ts

go run main.go

mvn compile exec:java -Dexec.mainClass="com.azure.openai.starter.ResponsesExampleEntra"

Troubleshooting

Issue Probieren Sie das aus
azd up schlägt fehl, da GPT-5-mini in der ausgewählten Region nicht verfügbar ist. Wählen Sie bei Aufforderung einen anderen Azure OpenAI-Modellstandort aus, oder legen Sie mit azd env set AZURE_LOCATION eastus2 eine andere Region fest und führen Sie azd up erneut aus.
azd up schlägt mit einer Rollenzuweisung oder einem Autorisierungsfehler fehl. Stellen Sie sicher, dass Ihr Konto Ressourcen und Rollenzuweisungen erstellen kann. Für diese Vorlage ist in der Regel die Rolle „Besitzer“ oder „Administrator für Benutzerzugriff“ erforderlich.
Die App gibt zurück 401 oder PermissionDenied. Vergewissern Sie sich, dass Sie bei demselben Mandanten und demselben Abonnement angemeldet sind, die bzw. das von azd up verwendet werden. Führen Sie az login und azd auth login aus und setzen Sie AZURE_TENANT_ID auf die Mandanten-ID aus az account show. Die Weitergabe von Rollenzuweisungen kann auch einige Minuten dauern.
DefaultAzureCredential failed to retrieve a token. Vergewissern Sie sich, dass Azure CLI installiert und bei az account show authentifiziert ist. Wenn Sie mehrere Mandanten verwenden, melden Sie sich mit az login --tenant <tenant-id> beim richtigen Mandanten an.
Die App gibt zurück model not found oder deployment not found. Vergewissern Sie sich, dass AZURE_OPENAI_DEPLOYMENT mit dem Azure OpenAI-Bereitstellungsnamen übereinstimmt. Der Standard des Starterkits lautet gpt-5-mini.
Die .NET-App erkennt keine Paketdirektiven. Installieren Sie die vom Starter Kit erforderliche .NET SDK-Version. Dateibasierte C#-Apps mit #:package einem aktuellen .NET SDK erfordern.
Die Go-App kann das Modul oder die Abhängigkeiten nicht finden. Führen Sie die Go-Befehle von src/go/responses_example_entra aus. Vergewissern Sie sich, dass Go 1.25.1 oder höher installiert ist.
Die Java-App schlägt mit einem Quell- oder Zielversionsfehler fehl. Vergewissern Sie sich, dass Java 21 oder höher installiert und vom Terminal ausgewählt wird.
Sie benötigen detaillierte Bereitstellungsprotokolle. Führen Sie azd up --debug aus.

Sie können die aktuellen Werte der Azure Developer CLI-Umgebung wie folgt überprüfen:

azd env get-values

Bereinigen von Ressourcen

Wenn Sie die Ressourcen nicht mehr benötigen, führen Sie den folgenden Befehl im Stammverzeichnis des StarterKit-Repositorys aus:

azd down --purge

Der Befehl löscht die Azure Ressourcen, die vom Starter Kit erstellt wurden, und hilft, laufende Gebühren zu stoppen.

Hilfe anfordern

Wenn Sie Hilfe zum Starter Kit benötigen, verwenden Sie die folgenden Ressourcen:

Nächste Schritte

Weitere Informationen zur Antwort-API

  • Last updated on