OpenAI sur Amazon Bedrock

Amazon Bedrock exécute les modèles OpenAI pris en charge sur une infrastructure gérée par AWS. Ce guide vous permet de comparer les fonctionnalités de l’API OpenAI prises en charge et de vous connecter à Bedrock avec le SDK OpenAI. Pour configurer votre déploiement, consultez la documentation AWS référencée sur cette page.

Les capacités du modèle et sa compatibilité avec les API déterminent ce que votre application peut faire. AWS gère l’accès aux modèles, leur disponibilité régionale, le routage, la facturation et les contrôles opérationnels de votre déploiement Bedrock.

Disponibilité des modèles sur Bedrock

Deux points de terminaison Amazon Bedrock donnent accès aux modèles OpenAI : bedrock-runtime et bedrock-mantle. Tous deux proposent les API Responses et Chat Completions compatibles avec OpenAI pour les modèles pris en charge. Les fonctionnalités disponibles diffèrent toutefois d’un point de terminaison à l’autre.

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

GPT-6 Sol et GPT-6 Luna sont disponibles via Bedrock Runtime, ainsi que via Mantle dans us-east-1 (Virginie du Nord). GPT-6 Astra est disponible via Bedrock Runtime, ainsi que via Mantle dans us-west-2 (Oregon). Les exemples de ce guide utilisent GPT-5.6 Terra dans us-east-2. Sélectionnez la région prise en charge avant de changer de modèle.

Pour obtenir les modalités d’accès et de configuration, consultez la documentation AWS sur la disponibilité des modèles par point de terminaison et les instructions relatives au point de terminaison Runtime.

Envoyer 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 de modèle adaptés à votre déploiement :

Les bibliothèques clientes dotées d’un fournisseur Bedrock déterminent l’URL de base 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 us-east-2. Les exemples Ruby configurent directement ce point de terminaison /openai/v1, car la route par défaut du fournisseur, /v1, ne prend pas en charge ce modèle.
Utilisez un identifiant de modèle Bedrock portant le préfixe openai.. Pour GPT-6 Sol et Luna, utilisez openai.gpt-6-sol ou openai.gpt-6-luna dans us-east-1.

Les exemples utilisent openai.gpt-5.6-terra dans us-east-2. Pour essayer GPT-6 Sol ou Luna, modifiez à la fois l’identifiant du modèle et la région. En Ruby, mettez également à jour la région dans la valeur explicite de base_url. Sur Bedrock Runtime, utilisez les identifiants de profil d’inférence pour les États-Unis, us.openai.gpt-6-sol et us.openai.gpt-6-luna, ou les identifiants mondiaux, global.openai.gpt-6-sol et global.openai.gpt-6-luna. Suivez les instructions d’AWS sur les points de terminaison de l’API Responses pour sélectionner l’URL de base de Runtime et le profil d’inférence.

L’exemple suivant utilise une clé API Bedrock stockée dans la variable AWS_BEARER_TOKEN_BEDROCK. Pour savoir comment générer et utiliser une clé, consultez la documentation sur les clés API Amazon 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>

Envoyer une requête à l’API Responses via Amazon Bedrock

JavaScript

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-terra",
  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-terra",
    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-terra",
		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-terra")
            .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-terra",
};
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-terra",
  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-terra",
    "input": "Write a haiku about cloud infrastructure."
  }'

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

Avant d’utiliser cette méthode, installez les dépendances facultatives nécessaires aux exemples qui utilisent la chaîne de fournisseurs d’identifiants AWS :

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. Avec .NET, utilisez une clé API Bedrock ou, si votre application nécessite la chaîne de fournisseurs d’identifiants AWS, envoyez une requête HTTP signée via un client pris en charge par AWS.

Envoyer une requête avec des identifiants Bedrock gérés par AWS

JavaScript

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-terra",
  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-terra",
    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-terra",
		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-terra")
            .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-terra",
  input: "Write a haiku about cloud infrastructure."
)

puts(response.output_text)

Disponibilité des fonctionnalités de l’API Responses

Ce tableau présente 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 ne garantit pas celle de tous ses outils ou modes de réponse.

Fonctionnalité	API OpenAI	Amazon Bedrock
Génération de texte	Disponible	Disponible
Images en entrée	Disponible	Disponible
Fichiers en entrée	Disponible	Disponible
Sorties structurées	Disponible	Disponible
Appel de fonction	Disponible	Disponible
Appel asynchrone d’outils	Disponible sur les modèles compatibles	Indisponible
Réponses en streaming	Disponible	Disponible
Connexions WebSocket	Disponible	Indisponible
Ajustement des instructions en cours de tour	Disponible sur les modèles compatibles	Indisponible
Fenêtre de contexte	Selon le modèle	Selon le modèle
Effort de raisonnement	Disponible	Disponible
Mises à jour du raisonnement	Disponible sur les modèles compatibles	Indisponible
Mode Pro	Disponible sur les modèles compatibles	Indisponible
Raisonnement persistant	Disponible sur les modèles compatibles	Disponible sur les modèles compatibles
Mise en cache des prompts	Disponible	Disponible
Appel d’outils par programmation	Disponible sur les modèles compatibles	Indisponible
Fonctionnement multi-agent	En bêta sur les modèles compatibles	Indisponible
Outils personnalisés	Disponible	Disponible
`tool_search` côté client	Disponible	Disponible
Recherche web hébergée	Disponible	Sur Mantle uniquement
Recherche de fichiers hébergée	Disponible	Indisponible
Utilisation de l’ordinateur	Disponible	Disponible
Outil shell	Disponible	Indisponible
Outil de génération d’images	Disponible	Indisponible
Serveurs MCP distants	Disponible	Indisponible

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

La prise en charge de tool_search côté client est indépendante de celle des outils hébergés et des serveurs MCP distants. Mantle propose la recherche web hébergée. La recherche de fichiers hébergée et les serveurs MCP distants sont indisponibles.

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 disposent d’une fenêtre de contexte d’un million de tokens. Celle de GPT-5.6 Sol, Terra et Luna ainsi que de GPT-6 Astra atteint 1 050 000 tokens. Consultez les fiches modèles OpenAI publiées par AWS pour connaître les limites propres à chaque modèle.

Différences entre les points de terminaison

Pour choisir entre Runtime et Mantle, tenez compte des différences suivantes dans la prise en charge de l’API Responses :

Fonctionnalité	Bedrock Runtime	Mantle
GPT-6 Astra	Disponible	Disponible dans `us-west-2` (Oregon)
GPT-6 Sol et GPT-6 Luna	Profils d’inférence pour les États-Unis et profils mondiaux	Disponible dans `us-east-1` (Virginie du Nord)
Utilisation de l’ordinateur	Disponible sur les modèles compatibles	Disponible sur les modèles compatibles
Réponses en streaming	Disponible	Disponible
Mode en arrière-plan (`background: true`)	Indisponible	Disponible selon les paramètres de conservation des données
Recherche web hébergée	Indisponible	Disponible sur les modèles compatibles
Poursuite d’un échange avec `previous_response_id`	Incluez `model` dans chaque requête	Le modèle peut être hérité de la réponse précédente

Runtime exige model même si vous fournissez previous_response_id. Le mode en arrière-plan est indépendant du streaming et ne correspond pas à l’appel de fonction asynchrone. Consultez la documentation AWS sur l’API Responses pour connaître les spécifications complètes des points 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 ressources pour choisir et configurer votre déploiement :

Aspect géré par AWS	Documentation AWS
Identifiants des modèles et API prises en charge	Fiches modèles OpenAI
Disponibilité des modèles et des points de terminaison par région AWS	Disponibilité des modèles et disponibilité des points de terminaison
Routage des requêtes par zone géographique ou à l’échelle mondiale	Inférence entre régions
Quotas de compte et demandes d’augmentation	Quotas Amazon Bedrock

Une région AWS ne correspond pas à une juridiction de résidence des données OpenAI. Si votre charge de travail doit respecter des contraintes géographiques, vérifiez les régions de destination de votre profil d’inférence et les conditions AWS applicables. La région indiquée dans l’URL de votre point de terminaison ne suffit pas.

Accès aux données et conservation

Amazon Bedrock gère séparément l’accès des opérateurs et la conservation des données :

Absence d’accès des opérateurs (ZOA) : les opérateurs AWS ne disposent d’aucun moyen technique pour se connecter aux systèmes de calcul sous-jacents de Mantle ou accéder aux données des clients sur ces systèmes. Consultez la présentation par AWS de la conception de l’environnement ZOA.
Politique de non-conservation des données (ZDR) : lorsque le mode de conservation effectif est none, AWS n’écrit pas les données des requêtes ou des réponses sur un support de stockage persistant.

Le paramètre store: false ne garantit pas la non-conservation des données. Pour les requêtes de l’API Responses dont le mode de conservation effectif est none, AWS refuse 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 conditions d’éligibilité et les modalités de configuration du compte ou du projet. Consultez la documentation sur la détection des abus dans Amazon Bedrock pour connaître les exigences de conservation et les exceptions propres à chaque modèle.

Si AWS détecte dans une image fournie en entrée du contenu qui semble être du matériel pédopornographique, AWS peut déplacer l’entrée ou la sortie signalée hors de l’environnement ZOA, la stocker et l’examiner à seule fin de déterminer s’il s’agit de matériel pédopornographique. AWS peut également effectuer un signalement auprès des autorités nationales.

Authentification et exploitation

Votre administrateur AWS contrôle l’accès au compte, aux modèles et aux fonctionnalités. Consultez la documentation AWS sur les clés API pour savoir comment créer les identifiants et gérer leur cycle de vie, et la documentation IAM pour gérer les identités et les autorisations. Les exemples du SDK OpenAI de cette page montrent comment fournir ces identifiants. Ils ne configurent pas les autorisations AWS.

Tarification

AWS facture l’utilisation d’Amazon Bedrock. Dans les régions commerciales, les tarifs de Bedrock sont identiques à ceux qu’OpenAI applique directement pour des services équivalents. Si vous utilisez un service propre à une région dans Bedrock, le tarif est celui du traitement régional dans l’API OpenAI. Les conditions commerciales d’Amazon s’appliquent à l’utilisation de Bedrock.

Consultez la tarification de l’API pour connaître les tarifs appliqués directement par OpenAI. Pour connaître les tarifs de Bedrock, les offres prises en charge et les options de facturation, consultez la tarification d’Amazon Bedrock et la fiche modèle correspondante.

Bedrock Managed Agents

Pour les sessions d’agents gérées sur AWS, consultez le guide Bedrock Managed Agents.

Étapes suivantes

Pour configurer ChatGPT Work et Codex, consultez le guide Utiliser ChatGPT Work et Codex avec Amazon Bedrock.

Suggestions

Premiers pas

Notions fondamentales

SDK et CLI

Fournisseurs de services cloud

Ressources

Anciennes API

Choisissez un modèle

Texte et code

Rédaction de prompts

Raisonnement

Images

Temps réel et audio

Modèles spécialisés

API Agents

Agents SDK

ChatKit

Recherche et récupération d’informations

Connectez des outils et des sources de données

Créez des workflows qui font appel à des outils

Ordinateur et code

Médias

GPT-Live

Realtime API

Créer des applications vocales

Connexions

Traitement audio

Mise en production

Performances et qualité

Évaluation

Coût et débit

Sécurité et gouvernance

Infrastructure et accès

Opérations

Concepts clés

Planification

Développement

Tests et publication

Spécifications de conversion

Guides

Ressources

Identité

Utilisation du forfait ChatGPT

Guides

Envoi de fichiers

API

Mesure des performances

API pour les annonceurs

Référence de l’API

Premiers pas

Premiers pas

Notions de base

Explorer

Disponible sur

Versions

Workflows

Capacités

Sites

dots

Espace ChatGPT

Référence

Personnalisation

Fichier de configuration

Configuration des agents

Étendre les fonctionnalités de ChatGPT et de Codex

Linux

Windows

Workflows de développement

Extensions et automatisation

Environnements

Codex Cloud

Développer avec Codex

Intégrations tierces

Référence

Autorisations

Codex Security

Cybersécurité

Premiers pas

Configuration des fonctionnalités

Identité et accès