Kommentar
Åtkomst till den här sidan kräver auktorisering. Du kan prova att logga in eller ändra kataloger.
Åtkomst till den här sidan kräver auktorisering. Du kan prova att ändra kataloger.
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:
- Ett Azure-abonnemang. Skapa en kostnadsfritt.
- Behörigheter för att skapa Azure resurser och rolltilldelningar i prenumerationen, till exempel Owner eller Användareåtkomstadministratör.
- Git.
- Azure CLI.
- Azure Developer CLI.
- 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:
-
DefaultAzureCredentialhä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 distributionsnamnetgpt-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:
- Azure OpenAI Starter Kit-lagringsplats.
- Problem med Azure OpenAI Starter Kit.
- Azure OpenAI-dokumentation.
- Azure CLI-dokumentation för utvecklare.
- Cognitive Services OpenAI-användarroll.