Kom igång med Azure OpenAI och svars-API:et

Den här artikeln visar hur du använder Azure OpenAI Starter Kit för att distribuera en Azure OpenAI-resurs och köra en liten Hello World-app. Appen använder Microsoft Entra ID-autentisering och OpenAI SDK för att anropa Azure OpenAI Responses API.

I slutet av den här artikeln kommer du att:

  • Distribuera Azure OpenAI med GPT-5-mini med hjälp av Azure Developer CLI.
  • Kör en lokal app som autentiserar med Microsoft Entra ID i stället för en API-nyckel.
  • Skicka en begäran till svars-API:et och skriv ut modellutdata.

Note

I den här artikeln används Azure OpenAI Starter Kit som grund för exemplen. Startpaketet innehåller infrastruktur som kod, Azure CLI-konfiguration för utvecklare och klientexempel för flera programmeringsspråk.

Kostnad

Azure resurser som skapas i den här artikeln faktureras till din Azure-prenumeration. Rensa resurserna när du är klar med artikeln för att undvika löpande avgifter.

Förutsättningar

För att slutföra den här artikeln behöver du:

  • Python 3.8 eller senare.
  • .NET SDK 10 eller senare. Startpaketet använder filbaserade C#-appar med paketdirektiv.
  • Node.js 18 eller senare.
  • Gå till 1.25.1 eller senare.
  • Java 21 eller senare.
  • Maven 3.9 eller senare.

Hämta koden

Klona Azure OpenAI Starter Kit-lagringsplatsen och öppna projektmappen.

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

Logga in på Azure

Logga in med både Azure CLI och Azure Developer CLI.

az login
azd auth login

Om ditt konto har åtkomst till mer än en klientorganisation kontrollerar du att den aktiva klientorganisationen är den klientorganisation där du vill distribuera resurserna.

az account show --query tenantId -o tsv

Distribuera Azure OpenAI

Kör följande Azure Developer CLI-kommando från lagringsplatsens rot:

azd up

Använd följande vägledning för att besvara anvisningarna:

Omedelbar Answer
Miljönamn Använd ett kort namn med små bokstäver, som aoai-hello. Värdet används i Azure resursnamn.
Prenumeration Välj den prenumeration där du vill skapa resurserna.
Plats Välj en region nära dig.
Azure OpenAI-modellplats Välj en region där GPT-5-mini är tillgänglig.

Distributionen tar vanligtvis flera minuter. När kommandot har slutförts har startpaketet provisionerat Azure OpenAI och distribuerat en GPT-5-mini-modell.

Konfigurera din lokala miljö

Hello World-appen använder din Azure inloggning för att få en Microsoft Entra åtkomsttoken. Ange slutpunkten som används av OpenAI-klienten.

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 använder distributionsnamn i API-anrop. Startpaketet returnerar namnet på GPT-5-mini-distributionen som AZURE_OPENAI_GPT_DEPLOYMENT_NAME. Den här artikeln mappar det värdet till AZURE_OPENAI_DEPLOYMENT så att koden är densamma i alla språk.

Skapa och köra hello world-appen

Skapa en fil med namnet hello_world_entra.py i src/python mappen.

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)

Installera Python beroenden och kör appen.

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

Skapa en fil med namnet hello_world_entra.cs i src/dotnet mappen.

#!/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());

Kör appen.

cd src/dotnet
dotnet run hello_world_entra.cs

Skapa en fil med namnet hello_world_entra.ts i src/typescript mappen.

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

Installera TypeScript-beroendena och kör appen.

cd src/typescript
npm install
npx tsx hello_world_entra.ts

Skapa en fil med namnet hello_world_entra.go i src/go/responses_example_entra mappen.

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

Kör appen.

cd src/go/responses_example_entra
go run hello_world_entra.go

Skapa en fil med namnet HelloWorldEntra.java i src/java/src/main/java/com/azure/openai/starter mappen.

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

Kör appen.

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

Det exakta utdataformatet varierar beroende på SDK. Du bör se utdata från den distribuerade Azure OpenAI-modellen som innehåller en kort hälsning.

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

Förstå koden

Hello World-appen har tre viktiga delar:

  • DefaultAzureCredential hämtar en Microsoft Entra token från din lokala Azure inloggning.
  • OpenAI-klienten pekar på din Azure OpenAI v1-slutpunkt: /openai/v1/.
  • Värdet model är Azure OpenAI-distributionsnamn. I det här startpaketet är distributionsnamnet gpt-5-mini.

Python-appen använder paketet openai med azure-identity. Hjälpen get_bearer_token_provider skapar en tokenprovider som OpenAI-klienten kan använda som autentiseringsuppgifter.

C#-appen använder paketet OpenAI med Azure.Identity. BearerTokenPolicy lägger till Microsoft Entra token till begäranden som skickas av ResponsesClient.

TypeScript-appen använder openai paketet med @azure/identity. Hjälpen getBearerTokenProvider skapar en tokenprovider som OpenAI-klienten kan använda som autentiseringsuppgifter.

Go-appen använder azidentity.NewDefaultAzureCredential med en Azure Core-ägartokenprincip. Policyn läggs till i OpenAI-klienten som mellanprogramvara så att begäranden använder Microsoft Entra ID-token.

Java-appen använder DefaultAzureCredentialBuilder med AuthenticationUtil.getBearerTokenSupplier. Tokenleverantören skickas till OpenAI-klienten genom att använda BearerTokenCredential.

Använd nyckellös autentisering i Azure-värdbaserade appar

Den här genomgången kör appen lokalt med din utvecklaridentitet. den distribuerar inte appen till Azure. När du hostar en app i Azure konfigurerar du värdtjänsten och Azure Identity-autentiseringsuppgiften för att använda en hanterad identitet. För en användartilldelad hanterad identitet konfigurerar du uttryckligen autentiseringsobjektet för att välja den identiteten. Vägledning om autentiseringsuppgifter och språkspecifika referenser finns i Lösenordslösa anslutningar för Azure tjänster.

Ge den värdbaserade appens identitet en lämplig Azure OpenAI-roll, till exempel Cognitive Services OpenAI-användare, i resursomfånget Azure OpenAI. Ditt utvecklarkontos rolltilldelning ger inte automatiskt åtkomst för den värdbaserade appen. Information om tilldelningssteg finns i Tilldela Azure roller med hjälp av Azure-portalen.

Kör startpaketets exempel

Startpaketet innehåller också ett större svars-API-exempel för varje språk.

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

Problematik Testa det här
azd up misslyckas eftersom GPT-5-mini inte är tillgängligt i den valda regionen. Välj en annan Azure OpenAI-modellplats när du uppmanas till det, eller ange en annan region med azd env set AZURE_LOCATION eastus2 och kör azd up igen.
azd up misslyckas med ett rolltilldelnings- eller auktoriseringsfel. Kontrollera att ditt konto kan skapa resurser och rolltilldelningar. Ägare eller administratör för användaråtkomst krävs vanligtvis för den här mallen.
Appen returnerar 401 eller PermissionDenied. Bekräfta att du är inloggad i samma klientorganisation och prenumeration som används av azd up. Kör az login, azd auth loginoch ange AZURE_TENANT_ID till klientorganisations-ID:t från az account show. Det kan också ta några minuter att sprida rolltilldelningen.
DefaultAzureCredential failed to retrieve a token. Bekräfta att Azure CLI har installerats och autentiserats med az account show. Om du använder flera klientorganisationer, loggar du in på rätt klientorganisation med az login --tenant <tenant-id>.
Appen returnerar model not found eller deployment not found. Bekräfta att AZURE_OPENAI_DEPLOYMENT matchar Azure OpenAI-distributionsnamnet. Standardinställningen för startpaketet är gpt-5-mini.
Den .NET appen känner inte igen paketdirektiv. Installera den .NET SDK-version som krävs av startpaketet. Filbaserade C#-appar med #:package kräver en nyligen .NET SDK.
Go-appen kan inte hitta modulen eller beroendena. Kör Go-kommandona från src/go/responses_example_entra. Bekräfta att Go 1.25.1 eller senare har installerats.
Java-appen misslyckas med ett käll- eller målversionsfel. Bekräfta att Java 21 eller senare har installerats och valts av terminalen.
Du behöver detaljerade distributionsloggar. Kör azd up --debug.

Du kan granska aktuella cli-miljövärden för Azure Developer med:

azd env get-values

Rensa resurser

När du inte längre behöver resurserna kör du följande kommando från startpaketets lagringsplatsrot:

azd down --purge

Kommandot tar bort Azure resurser som skapats av startpaketet och hjälper till att stoppa löpande avgifter.

Få hjälp

Om du behöver hjälp med startpaketet använder du följande resurser:

Nästa steg