Bien démarrer avec Azure OpenAI et l’API Réponses

Cet article vous montre comment utiliser le kit de démarrage OpenAI Azure pour déployer une ressource OpenAI Azure et exécuter une petite application hello world. L’application utilise l’authentification Microsoft Entra ID et le Kit de développement logiciel (SDK) OpenAI pour appeler l’API réponses OpenAI Azure.

À la fin de cet article, vous allez :

  • Déployez Azure OpenAI avec GPT-5-mini à l’aide de l’interface CLI Azure développeur.
  • Exécutez une application locale qui s’authentifie avec Microsoft Entra ID au lieu d’une clé API.
  • Envoyez une requête à l’API Réponses et imprimez la sortie du modèle.

Note

Cet article utilise le kit de démarrage OpenAI Azure comme base pour les exemples. Le kit de démarrage inclut l’infrastructure en tant que code, la configuration de l’interface CLI Azure développeur et des exemples clients pour plusieurs langages de programmation.

Coûts

Les ressources Azure créées dans cet article sont facturées à votre abonnement Azure. Pour éviter les frais en cours, nettoyez les ressources lorsque vous avez terminé l’article.

Prerequisites

Pour terminer cet article, vous avez besoin des éléments suivants :

  • Python 3.8 ou version ultérieure.
  • .NET SDK 10 ou version ultérieure. Le kit de démarrage utilise des applications C# basées sur des fichiers avec des directives de package.
  • Node.js 18 ou version ultérieure.
  • Accédez à la version 1.25.1 ou ultérieure.
  • Java 21 ou version ultérieure.
  • Maven 3.9 ou version ultérieure.

Obtenir le code

Clonez le dépôt Azure OpenAI Starter Kit et ouvrez le dossier du projet.

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

Connectez-vous à Azure

Connectez-vous à l’aide des Azure CLI et de l’interface CLI Azure Développeur.

az login
azd auth login

Si votre compte a accès à plusieurs locataires, vérifiez que le locataire actif est le locataire dans lequel vous souhaitez déployer les ressources.

az account show --query tenantId -o tsv

Déployer Azure OpenAI

Exécutez la commande suivante d’Azure Developer CLI depuis la racine du dépôt :

azd up

Utilisez les instructions suivantes pour répondre aux questions :

Prompt Answer
Nom de l’environnement Utilisez un nom court en minuscules, tel que aoai-hello. La valeur est utilisée dans les noms de ressources Azure.
Subscription Sélectionnez l’abonnement dans lequel vous souhaitez créer les ressources.
Lieu Sélectionnez une région proche de chez vous.
Emplacement du modèle Azure OpenAI Sélectionnez une région où GPT-5-mini est disponible.

Le déploiement prend généralement plusieurs minutes. Une fois la commande terminée, le kit de démarrage a provisionné Azure OpenAI et déployé un modèle GPT-5-mini.

Configurer votre environnement local

L’application hello world utilise votre connexion Azure pour obtenir un jeton d’accès Microsoft Entra. Définissez le point de terminaison utilisé par le client OpenAI.

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 utilise des noms de déploiement dans les appels d’API. Le kit de démarrage affiche le nom du déploiement GPT-5-mini sous la forme AZURE_OPENAI_GPT_DEPLOYMENT_NAME. Cet article associe cette valeur à AZURE_OPENAI_DEPLOYMENT, de sorte que le code soit identique dans toutes les langues.

Créer et exécuter l’application hello world

Créez un fichier nommé hello_world_entra.py dans le src/python dossier.

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)

Installez les dépendances Python et exécutez l’application.

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

Créez un fichier nommé hello_world_entra.cs dans le src/dotnet dossier.

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

Exécutez l’application.

cd src/dotnet
dotnet run hello_world_entra.cs

Créez un fichier nommé hello_world_entra.ts dans le src/typescript dossier.

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

Installez les dépendances TypeScript et exécutez l’application.

cd src/typescript
npm install
npx tsx hello_world_entra.ts

Créez un fichier nommé hello_world_entra.go dans le src/go/responses_example_entra dossier.

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

Exécutez l’application.

cd src/go/responses_example_entra
go run hello_world_entra.go

Créez un fichier nommé HelloWorldEntra.java dans le src/java/src/main/java/com/azure/openai/starter dossier.

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

Exécutez l’application.

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

Le format de sortie exact varie selon le Kit de développement logiciel (SDK). Vous devriez voir une sortie du modèle Azure OpenAI déployé contenant un court message d’accueil.

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

Comprendre le code

L’application hello world comporte trois parties importantes :

  • DefaultAzureCredential obtient un jeton Microsoft Entra depuis votre connexion locale à Azure.
  • Le client OpenAI pointe vers votre point de terminaison Azure OpenAI v1 : /openai/v1/.
  • La model valeur est le nom de déploiement d’OpenAI Azure. Dans ce kit de démarrage, le nom du déploiement est gpt-5-mini.

L’application Python utilise le openai package avec azure-identity. L’assistant get_bearer_token_provider crée un fournisseur de jetons que le client OpenAI peut utiliser comme moyen d’authentification.

L’application C# utilise le OpenAI package avec Azure.Identity. Le BearerTokenPolicy ajoute des jetons Microsoft Entra aux requêtes envoyées par le ResponsesClient.

L’application TypeScript utilise le openai package avec @azure/identity. L’assistant getBearerTokenProvider crée un fournisseur de jetons que le client OpenAI peut utiliser comme moyen d’authentification.

L’application Go utilise azidentity.NewDefaultAzureCredential avec une stratégie de jeton du porteur Azure Core. La stratégie est ajoutée au client OpenAI comme middleware afin que les requêtes utilisent des jetons Microsoft Entra ID.

L’application Java utilise DefaultAzureCredentialBuilder avec AuthenticationUtil.getBearerTokenSupplier. Le fournisseur de jeton est transmis au client OpenAI à l’aide de BearerTokenCredential.

Exécuter l’exemple de kit de démarrage

Le kit de démarrage inclut également un exemple d’API Réponses plus volumineux pour chaque langue.

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"

Dépannage

Problème Essayez les tâches suivantes
azd up échoue, car GPT-5-mini n’est pas disponible dans la région sélectionnée. Sélectionnez un autre emplacement de modèle OpenAI Azure lorsque vous y êtes invité, ou définissez une autre région avec azd env set AZURE_LOCATION eastus2 et réexécutez-laazd up.
azd up échoue avec une erreur d’attribution de rôle ou d’autorisation. Assurez-vous que votre compte peut créer des ressources et des attributions de rôles. L’administrateur d’accès utilisateur ou propriétaire est généralement requis pour ce modèle.
L’application retourne 401 ou PermissionDenied. Vérifiez que vous êtes connecté au même locataire et au même abonnement que celui utilisé par azd up. Exécutez az login, azd auth login, puis définissez AZURE_TENANT_ID sur l’ID du locataire à partir de az account show. La propagation de l’attribution de rôle peut également prendre quelques minutes.
DefaultAzureCredential failed to retrieve a token. Vérifiez que Azure CLI est installé et authentifié avec az account show. Si vous utilisez plusieurs locataires, connectez-vous au locataire approprié avec az login --tenant <tenant-id>.
L’application retourne model not found ou deployment not found. Vérifiez que AZURE_OPENAI_DEPLOYMENT correspond au nom du déploiement Azure OpenAI. La valeur par défaut du kit de démarrage est gpt-5-mini.
L'application .NET ne reconnaît pas les directives de package. Installez la version .NET SDK requise par le kit de démarrage. Les applications C# basées sur des fichiers avec #:package nécessitent un SDK .NET récent.
L’application Go ne trouve pas le module ou les dépendances. Exécutez les commandes Go à partir de src/go/responses_example_entra. Vérifiez que Go 1.25.1 ou version ultérieure est installé.
L’application Java échoue avec une erreur de version source ou cible. Vérifiez que Java 21 ou version ultérieure est installé et sélectionné par votre terminal.
Vous avez besoin de journaux de déploiement détaillés. Exécutez azd up --debug.

Vous pouvez inspecter les valeurs actuelles de l’environnement CLI Azure développeur avec :

azd env get-values

Nettoyer les ressources

Quand vous n’avez plus besoin des ressources, exécutez la commande suivante à partir de la racine du référentiel du kit de démarrage :

azd down --purge

La commande supprime les ressources Azure créées par le kit de démarrage et permet d’arrêter les frais en cours.

Obtenir de l’aide

Si vous avez besoin d’aide pour le kit de démarrage, utilisez ces ressources :

Étapes suivantes

En savoir plus sur l’API Réponses

  • Last updated on