OpenAI no Amazon Bedrock

O Amazon Bedrock executa os modelos compatíveis da OpenAI em infraestrutura gerenciada pela AWS. Use este guia para comparar o suporte aos recursos da API da OpenAI e se conectar usando o SDK da OpenAI. Para configurar sua implantação, consulte a documentação da AWS indicada nesta página.

Os recursos do modelo e a compatibilidade com a API determinam o que seu aplicativo pode fazer. A AWS gerencia o acesso aos modelos, a disponibilidade por região, o roteamento, o faturamento e os controles operacionais da sua implantação no Bedrock.

Como funciona a disponibilidade no Bedrock

Os modelos da OpenAI estão disponíveis por meio de dois endpoints do Amazon Bedrock, bedrock-runtime e bedrock-mantle. Para os modelos compatíveis, ambos oferecem suporte à API Responses e à API chat completions em formatos compatíveis com os da OpenAI. Os recursos disponíveis variam entre os endpoints.

Escolha o endpoint de acordo com os recursos de que seu aplicativo precisa. Por exemplo, a pesquisa na Web hospedada atualmente exige o Mantle. Para saber quais recursos específicos do Bedrock estão disponíveis e escolher um endpoint, consulte as diferenças entre os endpoints nesta página e a comparação de endpoints da AWS.

O GPT-6 Sol e o GPT-6 Luna estão disponíveis pelo Bedrock Runtime e, na região us-east-1 (Norte da Virgínia), também pelo Mantle. O GPT-6 Astra está disponível pelo Bedrock Runtime e, na região us-west-2 (Oregon), também pelo Mantle. Os exemplos deste guia usam o GPT-5.6 Terra em us-east-2. Selecione a região compatível antes de trocar de modelo.

Para obter acesso e configurar o serviço, consulte a disponibilidade de endpoints por modelo e as instruções para o endpoint do Runtime na documentação da AWS.

Como fazer requisições à API Responses

Estes exemplos usam o SDK da OpenAI com o endpoint do Mantle. Selecione a região da AWS e o ID do modelo para sua implantação.

As bibliotecas de cliente com um provedor do Bedrock determinam a URL base regional do Mantle a partir da região da AWS. Os provedores para JavaScript, Python, Go e Java usam https://bedrock-mantle.us-east-2.api.aws/openai/v1 nos exemplos deste guia para us-east-2. Os exemplos em Ruby configuram o endpoint /openai/v1 diretamente porque a rota padrão do provedor, /v1, não oferece suporte a esse modelo.
Use um ID de modelo do Bedrock com o prefixo openai.. Para o GPT-6 Sol e o GPT-6 Luna, use openai.gpt-6-sol ou openai.gpt-6-luna em us-east-1.

Os exemplos usam openai.gpt-5.6-terra em us-east-2. Para testar o GPT-6 Sol ou o GPT-6 Luna, altere tanto o ID do modelo quanto a região. Em Ruby, atualize também a região no valor explícito de base_url. No Bedrock Runtime, use os IDs dos perfis de inferência dos Estados Unidos, us.openai.gpt-6-sol e us.openai.gpt-6-luna, ou os IDs globais, global.openai.gpt-6-sol e global.openai.gpt-6-luna. Siga as instruções da AWS para o endpoint da API Responses para selecionar a URL base do Runtime e o perfil de inferência.

O exemplo a seguir usa uma chave de API do Bedrock armazenada na variável AWS_BEARER_TOKEN_BEDROCK. Para saber como gerar e usar uma chave de API do Bedrock, consulte Chaves de API do Amazon Bedrock.

Antes de usar qualquer um dos dois exemplos em Java, instale o provedor opcional do Bedrock para Java.

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

Envie uma requisição à API Responses pelo 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."
  }'

Para aplicativos que permanecem em execução por longos períodos, prefira a cadeia padrão de credenciais da AWS a um token de portador estático. Os provedores dos SDKs para JavaScript, Python, Go, Java e Ruby obtêm credenciais atualizadas da AWS e assinam cada tentativa de requisição com SigV4. A cadeia pode incluir credenciais configuradas com aws login, perfis compartilhados, funções de carga de trabalho e credenciais de instâncias ou contêineres.

Antes de usar os exemplos com a cadeia de credenciais da AWS, instale as dependências opcionais a seguir.

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

Atualmente, o SDK para .NET não oferece um provedor equivalente do Bedrock nem uma política de autenticação SigV4 da AWS. Use uma chave de API do Bedrock com .NET ou, se seu aplicativo exigir a cadeia de credenciais da AWS, envie uma requisição HTTP assinada por meio de um cliente com suporte da AWS.

Envie uma requisição com credenciais do Bedrock gerenciadas pela 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)

Disponibilidade dos recursos da API Responses

Consulte a tabela para identificar as diferenças em relação à API da OpenAI. A disponibilidade depende do modelo e do endpoint. O suporte a uma API não garante suporte a todas as ferramentas ou a todos os modos de resposta.

Recurso	API da OpenAI	Amazon Bedrock
Geração de texto	Disponível	Disponível
Entrada de imagens	Disponível	Disponível
Entrada de arquivos	Disponível	Disponível
Saídas estruturadas	Disponível	Disponível
Chamada de função	Disponível	Disponível
Chamada assíncrona de ferramentas	Disponível nos modelos compatíveis	Indisponível
Respostas em streaming	Disponível	Disponível
Conexões WebSocket	Disponível	Indisponível
Redirecionamento durante o turno	Disponível nos modelos compatíveis	Indisponível
Janela de contexto	Depende do modelo	Depende do modelo
Esforço de raciocínio	Disponível	Disponível
Atualizações de raciocínio	Disponível nos modelos compatíveis	Indisponível
Modo Pro	Disponível nos modelos compatíveis	Indisponível
Persistência do raciocínio	Disponível nos modelos compatíveis	Disponível nos modelos compatíveis
Cache de prompts	Disponível	Disponível
Chamada programática de ferramentas	Disponível nos modelos compatíveis	Indisponível
Uso de múltiplos agentes	Em beta nos modelos compatíveis	Indisponível
Ferramentas personalizadas	Disponível	Disponível
Uso de `tool_search` no cliente	Disponível	Disponível
Pesquisa na Web hospedada	Disponível	Somente no Mantle
Pesquisa de arquivos hospedada	Disponível	Indisponível
Uso do computador	Disponível	Disponível
Ferramenta de shell	Disponível	Indisponível
Ferramenta de geração de imagens	Disponível	Indisponível
Servidores MCP remotos	Disponível	Indisponível

O Amazon Bedrock não oferece suporte a chamadas assíncronas de ferramentas (async: true) nem a atualizações de raciocínio (itens de entrada configuration_update). O redirecionamento durante o turno exige WebSockets e não está disponível em nenhum dos dois endpoints do Bedrock.

O uso de tool_search no cliente é um recurso distinto do suporte a ferramentas hospedadas e a servidores MCP remotos. A pesquisa na Web hospedada está disponível pelo Mantle. A pesquisa de arquivos hospedada e os servidores MCP remotos estão indisponíveis.

O uso do computador está disponível no Runtime e no Mantle para os modelos compatíveis. Seu aplicativo executa as ações no computador e devolve os resultados ao modelo. Esse recurso dispensa um ambiente de execução hospedado pelo Bedrock.

No Amazon Bedrock, o GPT-5.4 e o GPT-5.5 oferecem uma janela de contexto de 1 milhão de tokens. Os modelos GPT-5.6 Sol, Terra e Luna e o GPT-6 Astra aceitam 1.050.000 tokens. Consulte os cartões dos modelos da OpenAI na documentação da AWS para verificar o limite de cada modelo.

Diferenças entre os endpoints

Ao escolher entre o Runtime e o Mantle, considere as seguintes diferenças na API Responses.

Recurso	Bedrock Runtime	Mantle
GPT-6 Astra	Disponível	Disponível em `us-west-2` (Oregon)
GPT-6 Sol e GPT-6 Luna	Perfis dos Estados Unidos e globais	Disponível em `us-east-1` (Norte da Virgínia)
Uso do computador	Disponível nos modelos compatíveis	Disponível nos modelos compatíveis
Respostas em streaming	Disponível	Disponível
Modo em segundo plano (`background: true`)	Indisponível	Disponível, dependendo das configurações de retenção de dados
Pesquisa na Web hospedada	Indisponível	Disponível nos modelos compatíveis
Continuação com `previous_response_id`	Inclua `model` em cada requisição	O modelo pode ser herdado da resposta anterior

O Runtime exige model mesmo quando você informa previous_response_id. O modo em segundo plano é independente do streaming e não se refere à chamada assíncrona de função. Consulte a documentação da API Responses da AWS para ver a especificação completa do endpoint. Para saber como configurar a pesquisa na Web e suas permissões, consulte o guia de pesquisa na Web da AWS.

Disponibilidade e operações

A AWS gerencia as opções de implantação e a disponibilidade do Amazon Bedrock. Consulte estas referências para escolher e configurar sua implantação.

Aspecto gerenciado pela AWS	Documentação da AWS
IDs dos modelos e APIs compatíveis	Cartões dos modelos da OpenAI
Disponibilidade de modelos e endpoints por região da AWS	Disponibilidade de modelos e disponibilidade de endpoints
Roteamento geográfico e global de requisições	Inferência entre regiões
Cotas da conta e solicitações de aumento	Cotas do Amazon Bedrock

Uma região da AWS não corresponde a uma jurisdição de residência de dados da OpenAI. Se sua carga de trabalho tiver requisitos de localização, verifique, além da região indicada na URL do endpoint, as regiões de destino do perfil de inferência e os termos aplicáveis da AWS.

Acesso e retenção de dados

O Amazon Bedrock tem controles separados para o acesso de operadores e a retenção de dados.

Acesso zero de operadores (ZOA) significa que os operadores da AWS não dispõem de nenhum mecanismo técnico para fazer login nos sistemas computacionais que executam o Mantle ou acessar os dados de clientes nesses sistemas. Saiba como a AWS implementa o ZOA.
Zero retenção de dados (ZDR) significa que a AWS não grava dados de requisições ou respostas em armazenamento durável quando o modo de retenção em vigor é none.

Definir store: false não garante ZDR. Para requisições à API Responses com o modo de retenção none em vigor, a AWS rejeita store: true e o modo em segundo plano fica indisponível.

Para modelos da OpenAI no Amazon Bedrock, a AWS não compartilha o conteúdo das requisições ou respostas com a OpenAI quando o modo de retenção em vigor é default ou none. Consulte a documentação da AWS sobre retenção de dados para conhecer os modos disponíveis, os critérios de elegibilidade e as opções de configuração por conta ou projeto. Consulte a documentação sobre detecção de abuso no Amazon Bedrock para verificar os requisitos de retenção e as exceções de cada modelo.

Se a AWS detectar indícios de material de abuso sexual infantil (CSAM) em uma imagem de entrada, poderá mover a entrada ou a saída sinalizada para fora do ambiente ZOA e armazená-la e analisá-la exclusivamente para determinar se o conteúdo é CSAM. A AWS também poderá comunicar o caso às autoridades nacionais.

Autenticação e operações

O administrador da AWS controla o acesso à conta, aos modelos e aos recursos. Consulte a documentação da AWS sobre chaves de API para saber como criar e gerenciar credenciais ao longo de seu ciclo de vida, e a documentação do IAM para saber mais sobre identidades e permissões. Os exemplos com o SDK da OpenAI nesta página mostram como fornecer essas credenciais. Eles não configuram as permissões da AWS.

Preços

A AWS cobra pelo uso do Amazon Bedrock. Nas regiões comerciais, os preços do Bedrock são iguais aos que a OpenAI cobra diretamente por serviços equivalentes. Ao usar no Bedrock um serviço específico de uma região, você paga a mesma tarifa do processamento regional na API da OpenAI. Os termos comerciais da Amazon se aplicam ao uso do Bedrock.

Consulte os preços da API para saber quanto a OpenAI cobra diretamente pelo uso da API. Para verificar as tarifas do Bedrock, os níveis de serviço disponíveis e as opções de faturamento, consulte os preços do Amazon Bedrock e o cartão do modelo correspondente.

Agentes gerenciados do Bedrock

Para usar sessões de agentes gerenciadas na AWS, consulte Agentes gerenciados do Bedrock.

Próximos passos

Para configurar o ChatGPT Work e o Codex, consulte Como usar o ChatGPT Work e o Codex com o Amazon Bedrock.

Sugestões

Primeiros passos

Conceitos fundamentais

SDKs e CLI

Provedores de nuvem

Recursos

APIs legadas

Escolha um modelo

Texto e código

Como escrever prompts

Raciocínio

Imagens

Tempo real e áudio

Modelos especializados

API de agentes

SDK de agentes

ChatKit

Busca e recuperação de informações

Conecte ferramentas e dados

Crie fluxos de trabalho com ferramentas

Computador e código

Mídia

GPT-Live

Realtime API

Desenvolver aplicações de voz

Conexões

Processamento de áudio

Coloque em produção

Desempenho e qualidade

Avaliação

Custo e taxa de processamento

Segurança e governança

Infraestrutura e acesso

Operações

Conceitos fundamentais

Planejar

Desenvolver

Testar e publicar

Especificações de conversão

Guias

Recursos

Identidade

Uso do plano do ChatGPT

Guias

Envio de arquivos

API

Mensuração

API para anunciantes

Referência da API

Primeiros passos

Primeiros passos

Fundamentos

Explorar

Disponível em

Versões

Fluxos de trabalho

Capacidades

Sites

dots

ChatGPT Space

Referência

Personalização

Arquivo de configuração

Configuração de agentes

Ampliar os recursos do ChatGPT e do Codex

Linux

Windows

Fluxos de trabalho de desenvolvimento

Ampliar recursos e automatizar tarefas

Ambientes

Codex Cloud

Desenvolver com o Codex

Integrações de terceiros

Referência

Permissões

Codex Security

Segurança cibernética

Primeiros passos

Configuração de recursos

Identidade e acesso