Aan de slag met Azure OpenAI en de Antwoorden-API

In dit artikel leest u hoe u de Azure OpenAI Starter Kit gebruikt om een Azure OpenAI-resource te implementeren en een kleine hallo wereld-app uit te voeren. De app maakt gebruik van Microsoft Entra ID-verificatie en de OpenAI SDK om de Azure OpenAI-antwoorden-API aan te roepen.

Aan het einde van dit artikel gaat u het volgende doen:

  • Implementeer Azure OpenAI met GPT-5 mini met behulp van de Azure Developer CLI.
  • Voer een lokale app uit die wordt geverifieerd met Microsoft Entra ID in plaats van een API-sleutel.
  • Verzend één aanvraag naar de Antwoorden-API en druk de modeluitvoer af.

Opmerking

In dit artikel wordt de Azure OpenAI Starter Kit gebruikt als basis voor de voorbeelden. De starterkit bevat Infrastructure as Code, Azure Developer CLI-configuratie en clientvoorbeelden voor meerdere programmeertalen.

Cost

Azure resources die in dit artikel zijn gemaakt, worden gefactureerd voor uw Azure-abonnement. Als u doorlopende kosten wilt voorkomen, moet u de resources opschonen wanneer u het artikel hebt voltooid.

Prerequisites

U hebt het volgende nodig om dit artikel te voltooien:

  • Python 3.8 of hoger.
  • .NET SDK 10 of hoger. De starterkit maakt gebruik van op bestanden gebaseerde C#-apps met pakketrichtlijnen.
  • Node.js 18 of hoger.
  • Ga 1.25.1 of hoger.
  • Java 21 of hoger.
  • Maven 3.9 of hoger.

De code ophalen

Kloon de Azure OpenAI Starter Kit-opslagplaats en open de projectmap.

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

Aanmelden bij Azure

Meld u aan met zowel de Azure CLI als de Azure Developer CLI.

az login
azd auth login

Als uw account toegang heeft tot meer dan één tenant, controleert u of de actieve tenant de tenant is waar u de resources wilt implementeren.

az account show --query tenantId -o tsv

Azure OpenAI implementeren

Voer de volgende Azure Developer CLI-opdracht uit vanuit de hoofdmap van de opslagplaats:

azd up

Gebruik de volgende richtlijnen om de prompts te beantwoorden:

Prompt Answer
Naam van de omgeving Gebruik een korte, kleine naam, zoals aoai-hello. De waarde wordt gebruikt in Azure resourcenamen.
Subscription Selecteer het abonnement waarin u de resources wilt maken.
Locatie Selecteer een regio bij u in de buurt.
locatie van Azure OpenAI-model Selecteer een regio waar GPT-5-mini beschikbaar is.

De implementatie duurt meestal enkele minuten. Wanneer de opdracht is voltooid, heeft de starterkit Azure OpenAI ingericht en een GPT-5-minimodel geïmplementeerd.

Uw lokale omgeving configureren

De hello world-app gebruikt uw Azure-aanmelding om een Microsoft Entra toegangstoken op te halen. Stel het eindpunt in dat wordt gebruikt door de OpenAI-client.

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 gebruikmaakt van implementatienamen in API-aanroepen. De starterkit geeft de naam van de GPT-5-mini-implementatie weer als AZURE_OPENAI_GPT_DEPLOYMENT_NAME. In dit artikel wordt die waarde aan AZURE_OPENAI_DEPLOYMENT gekoppeld, zodat de code in alle talen hetzelfde is.

De hallo wereld-app maken en uitvoeren

Maak een bestand met de naam hello_world_entra.py in de src/python map.

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)

Installeer de Python afhankelijkheden en voer de app uit.

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

Maak een bestand met de naam hello_world_entra.cs in de src/dotnet map.

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

Voer de app uit.

cd src/dotnet
dotnet run hello_world_entra.cs

Maak een bestand met de naam hello_world_entra.ts in de src/typescript map.

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

Installeer de TypeScript-afhankelijkheden en voer de app uit.

cd src/typescript
npm install
npx tsx hello_world_entra.ts

Maak een bestand met de naam hello_world_entra.go in de src/go/responses_example_entra map.

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

Voer de app uit.

cd src/go/responses_example_entra
go run hello_world_entra.go

Maak een bestand met de naam HelloWorldEntra.java in de src/java/src/main/java/com/azure/openai/starter map.

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

Voer de app uit.

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

De exacte uitvoerindeling verschilt per SDK. U zou uitvoer moeten zien van het geïmplementeerde Azure OpenAI-model die een korte begroeting bevat.

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

De code begrijpen

De hallo wereld-app heeft drie belangrijke onderdelen:

  • DefaultAzureCredential haalt een Microsoft Entra-token op via uw lokale aanmelding bij Azure.
  • De OpenAI-client verwijst naar uw Azure OpenAI v1-eindpunt: /openai/v1/.
  • De model waarde is de naam van de Azure OpenAI-implementatie. In deze starterkit is de naam van de implementatie gpt-5-mini.

De Python-app maakt gebruik van het openai pakket met azure-identity. De get_bearer_token_provider helper maakt een tokenprovider die de OpenAI-client als referentie kan gebruiken.

De C#-app maakt gebruik van het OpenAI pakket met Azure.Identity. De BearerTokenPolicy voegt Microsoft Entra-tokens toe aan verzoeken die door de ResponsesClient worden verzonden.

De TypeScript-app maakt gebruik van het openai pakket met @azure/identity. De getBearerTokenProvider helper maakt een tokenprovider die de OpenAI-client als referentie kan gebruiken.

De Go-app gebruikt azidentity.NewDefaultAzureCredential met een Azure Core bearer-tokenbeleid. Het beleid wordt als middleware toegevoegd aan de OpenAI-client, zodat aanvragen Microsoft Entra ID tokens gebruiken.

De Java-app gebruikt DefaultAzureCredentialBuilder met AuthenticationUtil.getBearerTokenSupplier. De tokenleverancier wordt doorgegeven aan de OpenAI-client met behulp van BearerTokenCredential.

Het voorbeeld van de starterkit uitvoeren

De starterkit bevat ook een groter antwoord-API-voorbeeld voor elke taal.

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 Probeer dit
azd up mislukt omdat GPT-5-mini niet beschikbaar is in de geselecteerde regio. Selecteer een andere Azure OpenAI-modellocatie wanneer hierom wordt gevraagd of stel een andere regio in met azd env set AZURE_LOCATION eastus2 en voer deze opnieuw uitazd up.
azd up mislukt met een roltoewijzing of autorisatiefout. Zorg ervoor dat uw account resources en roltoewijzingen kan maken. Eigenaar of beheerder van gebruikerstoegang is meestal vereist voor deze sjabloon.
De app geeft 401 of PermissionDenied terug. Controleer of u bent aangemeld bij dezelfde tenant en hetzelfde abonnement dat wordt gebruikt door azd up. Voer az login en azd auth login uit en stel AZURE_TENANT_ID in op de tenant-id van az account show. De propagatie van roltoewijzingen kan ook enkele minuten duren.
DefaultAzureCredential failed to retrieve a token. Controleer of Azure CLI is geïnstalleerd en geauthenticeerd met az account show. Als u meerdere tenants gebruikt, meldt u zich aan bij de juiste tenant met az login --tenant <tenant-id>.
De app geeft model not found of deployment not found terug. Controleer of AZURE_OPENAI_DEPLOYMENT deze overeenkomt met de naam van de Azure OpenAI-implementatie. De standaard starterkit is gpt-5-mini.
De .NET-app herkent pakketrichtlijnen niet. Installeer de .NET SDK-versie die is vereist voor de starterkit. Op bestanden gebaseerde C#-apps met #:package vereisen een recente .NET SDK.
De Go-app kan de module of afhankelijkheden niet vinden. Voer de Go-opdrachten uit vanaf src/go/responses_example_entra. Controleer of Go 1.25.1 of hoger is geïnstalleerd.
De Java-app mislukt vanwege een fout met de bron- of doelversie. Controleer of Java 21 of hoger is geïnstalleerd en geselecteerd door uw terminal.
U hebt gedetailleerde implementatielogboeken nodig. Voer azd up --debuguit.

U kunt de huidige Azure Cli-omgevingswaarden voor ontwikkelaars controleren met:

azd env get-values

De hulpbronnen opschonen

Wanneer u de resources niet meer nodig hebt, voert u de volgende opdracht uit vanuit de hoofdmap van de starterkit-repository:

azd down --purge

Met de opdracht worden de Azure-resources verwijderd die door de starter kit zijn gemaakt, en worden verdere kosten helpen voorkomen.

Hulp krijgen

Als u hulp nodig hebt met de starterkit, gebruikt u deze resources:

Volgende stappen 

Meer informatie over de Antwoorden-API

  • Last updated on