Modèles OpenAI dans Amazon Bedrock

Amazon Bedrock exécute les modèles OpenAI pris en charge sur une infrastructure gérée par AWS. Utilisez ce guide pour comparer la prise en charge des fonctionnalités de l’API OpenAI et vous connecter avec le SDK OpenAI. Pour configurer votre déploiement, consultez la documentation AWS accessible depuis cette page.

Comprendre la disponibilité dans Bedrock

Les modèles OpenAI sont accessibles via deux points de terminaison Amazon Bedrock : bedrock-runtime et bedrock-mantle. Tous deux prennent en charge les API Responses et Chat Completions compatibles avec OpenAI pour les modèles pris en charge, mais les fonctionnalités disponibles diffèrent.

Choisissez votre point de terminaison en fonction des capacités dont votre application a besoin. Par exemple, la recherche web hébergée nécessite actuellement Mantle. Consultez les différences entre les points de terminaison sur cette page et le comparatif des points de terminaison d’AWS pour connaître les capacités propres à Bedrock et choisir votre point de terminaison.

Pour l’accès et la configuration, consultez l’annonce de GPT-6 Astra et les instructions relatives au point de terminaison Runtime d’AWS.

Envoyez des requêtes à l’API Responses

Ces exemples utilisent le SDK OpenAI avec le point de terminaison Mantle. Sélectionnez la région AWS et l’identifiant du modèle pour votre déploiement :

• Les bibliothèques clientes dotées d’un fournisseur Bedrock déterminent l’URL de base régionale de Mantle à partir de la région AWS. Les fournisseurs JavaScript, Python, Go et Java utilisent https://bedrock-mantle.us-east-2.api.aws/openai/v1 pour les exemples de ce guide dans la région us-east-2. Les exemples Ruby configurent directement ce point de terminaison /openai/v1, car la route par défaut /v1 du fournisseur ne prend pas en charge ce modèle.
• Utilisez un identifiant de modèle Bedrock avec le préfixe openai., par exemple openai.gpt-5.6-sol.

Les exemples utilisent openai.gpt-5.6-sol dans la région us-east-2. Pour Runtime, suivez les instructions d’AWS relatives au point de terminaison de l’API Responses afin de sélectionner l’URL de base et le profil d’inférence. Ne réutilisez pas un identifiant de modèle Mantle sans vérifier les exigences de Runtime.

L’exemple suivant utilise une clé API Bedrock stockée dans AWS_BEARER_TOKEN_BEDROCK. Consultez la documentation sur les clés API Amazon Bedrock pour savoir comment générer et utiliser une clé API Bedrock.

Installez le fournisseur Bedrock facultatif pour Java avant d’utiliser l’un ou l’autre des exemples Java :

12345<dependency>
  <groupId>com.openai</groupId>
  <artifactId>openai-java-bedrock</artifactId>
  <version>4.57.0</version>
</dependency>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16import OpenAI from "openai";
import { bedrock } from "openai/providers/bedrock";

const client = new OpenAI({
  provider: bedrock({
    region: "us-east-2",
    apiKey: process.env.AWS_BEARER_TOKEN_BEDROCK,
  }),
});

const response = await client.responses.create({
  model: "openai.gpt-5.6-sol",
  input: "Write a haiku about cloud infrastructure.",
});

console.log(response.output_text);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18import os

from openai import OpenAI
from openai.providers import bedrock

client = OpenAI(
    provider=bedrock(
        region="us-east-2",
        api_key=os.environ["AWS_BEARER_TOKEN_BEDROCK"],
    )
)

response = client.responses.create(
    model="openai.gpt-5.6-sol",
    input="Write a haiku about cloud infrastructure.",
)

print(response.output_text)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32package main

import (
	"context"
	"fmt"
	"os"

	"github.com/openai/openai-go/v3"
	"github.com/openai/openai-go/v3/bedrock"
	"github.com/openai/openai-go/v3/responses"
)

func main() {
	client, err := bedrock.NewClient(context.Background(), bedrock.Config{
		AWSRegion: "us-east-2",
		APIKey:    os.Getenv("AWS_BEARER_TOKEN_BEDROCK"),
	})
	if err != nil {
		panic(err)
	}

	response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
		Model: "openai.gpt-5.6-sol",
		Input: responses.ResponseNewParamsInputUnion{
			OfString: openai.String("Write a haiku about cloud infrastructure."),
		},
	})
	if err != nil {
		panic(err)
	}
	fmt.Println(response.OutputText())
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.BedrockOpenAIOkHttpClient;
import com.openai.models.responses.ResponseCreateParams;

public final class AmazonBedrockCreateResponseExample {
  private AmazonBedrockCreateResponseExample() {}

  public static void main(String[] args) {
    OpenAIClient client =
        BedrockOpenAIOkHttpClient.builder()
            .awsRegion("us-east-2")
            .apiKey(System.getenv("AWS_BEARER_TOKEN_BEDROCK"))
            .build();

    ResponseCreateParams params =
        ResponseCreateParams.builder()
            .model("openai.gpt-5.6-sol")
            .input("Write a haiku about cloud infrastructure.")
            .build();

    client.responses().create(params).output().stream()
        .flatMap(item -> item.message().stream())
        .flatMap(message -> message.content().stream())
        .flatMap(content -> content.outputText().stream())
        .forEach(text -> System.out.println(text.text()));
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24using System.ClientModel;
using OpenAI.Responses;
#pragma warning disable OPENAI001

string key = Environment.GetEnvironmentVariable("AWS_BEARER_TOKEN_BEDROCK")!;
ResponsesClient client = new(
    new ApiKeyCredential(key),
    new ResponsesClientOptions
    {
        Endpoint = new Uri("https://bedrock-mantle.us-east-2.api.aws/openai/v1"),
    }
);

CreateResponseOptions options = new()
{
    Model = "openai.gpt-5.6-sol",
};
options.InputItems.Add(
    ResponseItem.CreateUserMessageItem("Write a haiku about cloud infrastructure.")
);

ResponseResult response = await client.CreateResponseAsync(options);

Console.WriteLine(response.GetOutputText());

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16require "openai"

client = OpenAI::Client.new(
  provider: OpenAI::Providers.bedrock(
    region: "us-east-2",
    base_url: "https://bedrock-mantle.us-east-2.api.aws/openai/v1",
    api_key: ENV.fetch("AWS_BEARER_TOKEN_BEDROCK")
  )
)

response = client.responses.create(
  model: "openai.gpt-5.6-sol",
  input: "Write a haiku about cloud infrastructure."
)

puts(response.output_text)

1
2
3
4
5
6
7curl "https://bedrock-mantle.us-east-2.api.aws/openai/v1/responses" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $AWS_BEARER_TOKEN_BEDROCK" \
  -d '{
    "model": "openai.gpt-5.6-sol",
    "input": "Write a haiku about cloud infrastructure."
  }'

Pour les applications qui s’exécutent sur une longue durée, privilégiez la chaîne d’identifiants AWS standard plutôt qu’un token porteur statique. Les fournisseurs des SDK JavaScript, Python, Go, Java et Ruby récupèrent des identifiants AWS à jour et signent chaque tentative de requête avec SigV4. La chaîne peut inclure des identifiants configurés avec aws login, des profils partagés, des rôles de charge de travail et des identifiants d’instance ou de conteneur.

Installez les dépendances facultatives des exemples utilisant la chaîne d’identifiants AWS avant d’utiliser cette méthode :

1234npm install @aws-sdk/credential-provider-node @smithy/hash-node @smithy/signature-v4
pip install 'openai[bedrock]'
go get github.com/openai/openai-go/v3/bedrock
bundle add aws-sdk-core

Le SDK .NET ne propose actuellement ni fournisseur Bedrock équivalent ni stratégie d’authentification AWS SigV4. Utilisez une clé API Bedrock avec .NET, ou envoyez une requête HTTP signée via un client pris en charge par AWS lorsque votre application nécessite la chaîne d’identifiants AWS.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18import OpenAI from "openai";
import { defaultProvider } from "@aws-sdk/credential-provider-node";
import { bedrock } from "openai/providers/bedrock/aws";

const client = new OpenAI({
  provider: bedrock({
    region: "us-east-2",
    endpoint: "mantle",
    credentialProvider: defaultProvider(),
  }),
});

const response = await client.responses.create({
  model: "openai.gpt-5.6-sol",
  input: "Write a haiku about cloud infrastructure.",
});

console.log(response.output_text);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16from openai import OpenAI
from openai.providers import bedrock

client = OpenAI(
    provider=bedrock(
        region="us-east-2",
        api_key=None,
    )
)

response = client.responses.create(
    model="openai.gpt-5.6-sol",
    input="Write a haiku about cloud infrastructure.",
)

print(response.output_text)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37package main

import (
	"context"
	"fmt"

	"github.com/aws/aws-sdk-go-v2/config"
	"github.com/openai/openai-go/v3"
	"github.com/openai/openai-go/v3/bedrock"
	"github.com/openai/openai-go/v3/responses"
)

func main() {
	awsConfig, err := config.LoadDefaultConfig(context.Background())
	if err != nil {
		panic(err)
	}

	client, err := bedrock.NewClient(context.Background(), bedrock.Config{
		AWSRegion:              "us-east-2",
		AWSCredentialsProvider: awsConfig.Credentials,
	})
	if err != nil {
		panic(err)
	}

	response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
		Model: "openai.gpt-5.6-sol",
		Input: responses.ResponseNewParamsInputUnion{
			OfString: openai.String("Write a haiku about cloud infrastructure."),
		},
	})
	if err != nil {
		panic(err)
	}
	fmt.Println(response.OutputText())
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.BedrockOpenAIOkHttpClient;
import com.openai.models.responses.ResponseCreateParams;
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;

public final class AmazonBedrockCreateResponseWithAwsCredentialsExample {
  private AmazonBedrockCreateResponseWithAwsCredentialsExample() {}

  public static void main(String[] args) {
    OpenAIClient client =
        BedrockOpenAIOkHttpClient.builder()
            .awsRegion("us-east-2")
            .awsCredentialsProvider(DefaultCredentialsProvider.create())
            .build();

    ResponseCreateParams params =
        ResponseCreateParams.builder()
            .model("openai.gpt-5.6-sol")
            .input("Write a haiku about cloud infrastructure.")
            .build();

    client.responses().create(params).output().stream()
        .flatMap(item -> item.message().stream())
        .flatMap(message -> message.content().stream())
        .flatMap(content -> content.outputText().stream())
        .forEach(text -> System.out.println(text.text()));
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16require "openai"

client = OpenAI::Client.new(
  provider: OpenAI::Providers.bedrock(
    region: "us-east-2",
    base_url: "https://bedrock-mantle.us-east-2.api.aws/openai/v1",
    api_key: nil
  )
)

response = client.responses.create(
  model: "openai.gpt-5.6-sol",
  input: "Write a haiku about cloud infrastructure."
)

puts(response.output_text)

Disponibilité des fonctionnalités de l’API Responses

Utilisez ce tableau pour repérer les différences par rapport à l’API OpenAI. La disponibilité dépend du modèle et du point de terminaison ; la prise en charge d’une API n’implique pas celle de tous les outils ou modes de réponse.

L’appel asynchrone d’outils (async: true) et les mises à jour du raisonnement (éléments d’entrée configuration_update) ne sont pas pris en charge sur Amazon Bedrock. La réorientation en cours de tour nécessite des connexions WebSocket et n’est disponible sur aucun des deux points de terminaison Bedrock.

La fonctionnalité tool_search côté client est distincte des outils hébergés et de la prise en charge des serveurs MCP distants. La recherche web hébergée est disponible via Mantle ; la recherche de fichiers hébergée et les serveurs MCP distants ne sont pas disponibles.

L’utilisation de l’ordinateur est disponible sur Runtime et Mantle pour les modèles compatibles. Votre application exécute les actions sur l’ordinateur et renvoie les résultats au modèle ; cette fonctionnalité ne nécessite pas d’environnement d’exécution hébergé par Bedrock.

Sur Amazon Bedrock, GPT-5.4 et GPT-5.5 prennent en charge une fenêtre de contexte d’un million de tokens ; GPT-5.6 Sol, Terra, Luna et GPT-6 Astra prennent en charge 1 050 000 tokens. Consultez les fiches modèles OpenAI dans la documentation AWS pour connaître les limites propres à chaque modèle.

Différences entre les points de terminaison

Tenez compte de ces différences de l’API Responses pour choisir entre Runtime et Mantle :

Runtime exige model même lorsque vous fournissez previous_response_id. Le mode en arrière-plan est distinct de la diffusion en continu et ne correspond pas à l’appel asynchrone de fonctions. Consultez la documentation AWS de l’API Responses pour connaître l’ensemble des règles du point de terminaison. Pour les autorisations et la configuration de la recherche web, consultez le guide AWS de la recherche web.

Disponibilité et exploitation

AWS gère les options de déploiement et la disponibilité d’Amazon Bedrock. Consultez ces références pour choisir et configurer votre déploiement :

Une région AWS n’est pas une juridiction de résidence des données OpenAI. Si votre charge de travail impose des exigences de localisation, vérifiez les régions de destination de votre profil d’inférence et les conditions AWS applicables, et pas uniquement la région figurant dans l’URL de votre point de terminaison.

Accès aux données et conservation

Amazon Bedrock utilise des contrôles distincts pour l’accès des opérateurs et la conservation des données :

• Avec l’absence d’accès des opérateurs (ZOA) , les opérateurs AWS ne disposent d’aucun mécanisme technique pour se connecter aux systèmes de calcul sous-jacents de Mantle ou accéder aux données clients qui s’y trouvent. Consultez la conception ZOA d’AWS.
• Avec la politique de non-conservation des données (ZDR) , AWS n’écrit pas les données des requêtes ou des réponses sur un stockage persistant lorsque le mode de conservation effectif est none.

Le paramètre store: false ne garantit pas la ZDR. Pour les requêtes de l’API Responses dont le mode de conservation effectif est none, AWS rejette store: true et le mode en arrière-plan est indisponible.

Pour les modèles OpenAI dans Amazon Bedrock, AWS ne partage pas le contenu des requêtes ou des réponses avec OpenAI lorsque le mode de conservation effectif est default ou none. Consultez la documentation AWS sur la conservation des données pour connaître les modes disponibles, les critères d’éligibilité et la configuration du compte ou du projet. Consultez la détection des abus dans Amazon Bedrock pour connaître les exigences de conservation et les exceptions propres à chaque modèle.

Authentification et exploitation

Votre administrateur AWS contrôle l’accès aux comptes, aux modèles et aux fonctionnalités. Consultez la documentation AWS sur les clés API pour la création et le cycle de vie des identifiants, et la documentation IAM pour les identités et les autorisations. Les exemples du SDK OpenAI sur cette page montrent comment fournir ces identifiants ; ils ne configurent pas les autorisations AWS.

Tarifs

L’utilisation d’Amazon Bedrock est facturée par AWS. Les tarifs de Bedrock dans les régions commerciales correspondent aux tarifs directs d’OpenAI pour des services équivalents. L’utilisation d’un service propre à une région dans Bedrock est facturée au même tarif que le traitement régional dans l’API OpenAI. Les conditions commerciales d’Amazon s’appliquent à l’utilisation de Bedrock.

Consultez les tarifs de l’API pour connaître les tarifs directs de l’API OpenAI. Pour les tarifs de Bedrock, les offres prises en charge et les options de facturation, consultez les tarifs d’Amazon Bedrock et la fiche modèle concernée.

Étapes suivantes

Pour la configuration dans ChatGPT Work et Codex, consultez Utiliser ChatGPT Work et Codex avec Amazon Bedrock.