OpenAI en Amazon Bedrock

Amazon Bedrock ejecuta los modelos de OpenAI compatibles en infraestructura administrada por AWS. Usa esta guía para comparar las funciones disponibles en la API de OpenAI y en Bedrock y conectarte con el SDK de OpenAI. Para configurar tu implementación, consulta la documentación de AWS que se enlaza desde esta página.

Las capacidades del modelo y la compatibilidad con la API determinan lo que puede hacer tu aplicación. AWS administra el acceso a los modelos, la disponibilidad regional, el enrutamiento, la facturación y los controles operativos de tu implementación en Bedrock.

Cómo funciona la disponibilidad en Bedrock

Los modelos de OpenAI están disponibles a través de dos puntos de acceso de Amazon Bedrock: bedrock-runtime y bedrock-mantle. Para los modelos compatibles, ambos admiten la API Responses y la API para completar chats, compatibles con las de OpenAI. Las funciones disponibles varían según el punto de acceso.

Elige el punto de acceso según las capacidades que necesite tu aplicación. Por ejemplo, la búsqueda web alojada actualmente requiere Mantle. Para conocer las capacidades específicas de Bedrock y elegir un punto de acceso, consulta las diferencias entre los puntos de acceso en esta página y la comparación de puntos de acceso de AWS.

GPT-6 Sol y GPT-6 Luna están disponibles a través de Bedrock Runtime y también a través de Mantle en us-east-1 (norte de Virginia). GPT-6 Astra está disponible a través de Bedrock Runtime y también a través de Mantle en us-west-2 (Oregón). Los ejemplos de esta guía usan GPT-5.6 Terra en us-east-2. Antes de cambiar el modelo, selecciona la región compatible con el modelo que quieres usar.

Para obtener acceso y configurar la conexión, consulta la documentación de AWS sobre la disponibilidad de los modelos por punto de acceso y las instrucciones para el punto de acceso de Runtime.

Enviar solicitudes a la API Responses

Estos ejemplos usan el SDK de OpenAI con el punto de acceso de Mantle. Selecciona la región de AWS y el ID del modelo para tu implementación:

Las bibliotecas cliente que incluyen un proveedor de Bedrock determinan la URL base regional de Mantle a partir de la región de AWS. Para los ejemplos de esta guía, los proveedores de JavaScript, Python, Go y Java usan https://bedrock-mantle.us-east-2.api.aws/openai/v1, que corresponde a us-east-2. En los ejemplos de Ruby se configura directamente el punto de acceso /openai/v1 porque la ruta predeterminada del proveedor, /v1, no admite este modelo.
Usa un ID de modelo de Bedrock con el prefijo openai.. Para GPT-6 Sol y Luna, usa openai.gpt-6-sol u openai.gpt-6-luna en us-east-1.

Los ejemplos usan openai.gpt-5.6-terra en us-east-2. Para probar GPT-6 Sol o Luna, cambia tanto el ID del modelo como la región. En Ruby, actualiza también la región en el valor explícito de base_url. En Bedrock Runtime, usa los ID de los perfiles de inferencia de Estados Unidos, us.openai.gpt-6-sol y us.openai.gpt-6-luna, o los ID globales, global.openai.gpt-6-sol y global.openai.gpt-6-luna. Sigue las instrucciones de AWS para el punto de acceso de la API Responses para seleccionar la URL base de Runtime y el perfil de inferencia.

El siguiente ejemplo usa una clave de API de Bedrock almacenada en AWS_BEARER_TOKEN_BEDROCK. Para saber cómo generar y usar una clave de API de Bedrock, consulta la documentación sobre las claves de API de Amazon Bedrock.

Antes de usar cualquiera de los dos ejemplos de Java, instala el proveedor opcional de Bedrock para Java:

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

Enviar una solicitud a la API Responses a través de 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 aplicaciones que se ejecutan durante períodos prolongados, es preferible usar la cadena estándar de credenciales de AWS en lugar de un token de portador estático. Los proveedores de los SDK de JavaScript, Python, Go, Java y Ruby obtienen credenciales vigentes de AWS y firman la solicitud con SigV4 en cada intento de envío. La cadena puede incluir credenciales configuradas con aws login, perfiles compartidos, roles de cargas de trabajo y credenciales de instancias o contenedores.

Antes de usar los ejemplos con la cadena de credenciales de AWS, instala las dependencias opcionales:

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

Por el momento, el SDK de .NET no ofrece un proveedor equivalente de Bedrock ni una política de autenticación con AWS SigV4. Usa una clave de API de Bedrock con .NET o, si tu aplicación requiere la cadena de credenciales de AWS, envía una solicitud HTTP firmada a través de un cliente admitido por AWS.

Enviar una solicitud con credenciales de Bedrock administradas por 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)

Disponibilidad de las funciones de la API Responses

Usa esta tabla para identificar las diferencias con la API de OpenAI. La disponibilidad depende del modelo y del punto de acceso. La compatibilidad con una API no implica que todas sus herramientas o modos de respuesta estén disponibles.

Capacidad	API de OpenAI	Amazon Bedrock
Generación de texto	Disponible	Disponible
Entrada de imágenes	Disponible	Disponible
Entrada de archivos	Disponible	Disponible
Resultados estructurados	Disponible	Disponible
Llamada a funciones	Disponible	Disponible
Llamada asíncrona a herramientas	Disponible en modelos compatibles	No disponible
Respuestas en streaming	Disponible	Disponible
Conexiones WebSocket	Disponible	No disponible
Ajuste de instrucciones durante un turno	Disponible en modelos compatibles	No disponible
Ventana de contexto	Depende del modelo	Depende del modelo
Esfuerzo de razonamiento	Disponible	Disponible
Actualizaciones del razonamiento	Disponible en modelos compatibles	No disponible
Modo Pro	Disponible en modelos compatibles	No disponible
Razonamiento persistente	Disponible en modelos compatibles	Disponible en modelos compatibles
Almacenamiento en caché de prompts	Disponible	Disponible
Llamada programática a herramientas	Disponible en modelos compatibles	No disponible
Múltiples agentes	En beta en modelos compatibles	No disponible
Herramientas personalizadas	Disponible	Disponible
Búsqueda con `tool_search` del lado del cliente	Disponible	Disponible
Búsqueda web alojada	Disponible	Solo en Mantle
Búsqueda de archivos alojada	Disponible	No disponible
Uso de la computadora	Disponible	Disponible
Herramienta de shell	Disponible	No disponible
Herramienta de generación de imágenes	Disponible	No disponible
Servidores MCP remotos	Disponible	No disponible

Amazon Bedrock no admite la llamada asíncrona a herramientas (async: true) ni las actualizaciones del razonamiento (elementos de entrada configuration_update). El ajuste de instrucciones durante un turno requiere WebSockets y no está disponible en ninguno de los dos puntos de acceso de Bedrock.

El uso de tool_search del lado del cliente es independiente de la compatibilidad con herramientas alojadas y servidores MCP remotos. La búsqueda web alojada está disponible a través de Mantle. La búsqueda de archivos alojada y los servidores MCP remotos no están disponibles.

El uso de la computadora está disponible en Runtime y Mantle para los modelos compatibles. Tu aplicación ejecuta las acciones en la computadora y devuelve los resultados al modelo. Esta capacidad no requiere un entorno de ejecución alojado en Bedrock.

En Amazon Bedrock, GPT-5.4 y GPT-5.5 admiten una ventana de contexto de un millón de tokens. GPT-5.6 Sol, Terra y Luna, así como GPT-6 Astra, admiten 1 050 000 tokens. Consulta las tarjetas de los modelos de OpenAI en la documentación de AWS para conocer los límites de cada modelo.

Diferencias entre los puntos de acceso

Ten en cuenta estas diferencias en la API Responses al elegir entre Runtime y Mantle:

Capacidad	Bedrock Runtime	Mantle
GPT-6 Astra	Disponible	Disponible en `us-west-2` (Oregón)
GPT-6 Sol y GPT-6 Luna	Perfiles de Estados Unidos y globales	Disponible en `us-east-1` (norte de Virginia)
Uso de la computadora	Disponible en modelos compatibles	Disponible en modelos compatibles
Respuestas en streaming	Disponible	Disponible
Modo en segundo plano (`background: true`)	No disponible	Disponible según la configuración de retención de datos
Búsqueda web alojada	No disponible	Disponible en modelos compatibles
Continuar con `previous_response_id`	Incluye `model` en cada solicitud	El modelo se puede heredar de la respuesta anterior

Runtime requiere model incluso cuando incluyes previous_response_id. El modo en segundo plano es independiente del streaming y no se refiere a la llamada asíncrona a funciones. Consulta la documentación de AWS sobre la API Responses para conocer la especificación completa del punto de acceso. Para conocer los permisos y la configuración de la búsqueda web, consulta la guía de búsqueda web de AWS.

Disponibilidad y operaciones

AWS administra las opciones de implementación y la disponibilidad de Amazon Bedrock. Consulta estos recursos para elegir y configurar tu implementación:

Aspecto que administra AWS	Documentación de AWS
ID de modelos y API compatibles	Tarjetas de los modelos de OpenAI
Disponibilidad de modelos y puntos de acceso por región de AWS	Disponibilidad de modelos y disponibilidad de puntos de acceso
Enrutamiento geográfico y global de solicitudes	Inferencia entre regiones
Cuotas de la cuenta y solicitudes de aumento	Cuotas de Amazon Bedrock

Una región de AWS no equivale a una jurisdicción de residencia de datos de OpenAI. Si tu carga de trabajo tiene requisitos de ubicación, revisa las regiones de destino de tu perfil de inferencia y las condiciones aplicables de AWS, además de la región que aparece en la URL de tu punto de acceso.

Acceso a los datos y retención

Amazon Bedrock usa controles independientes para el acceso de los operadores y la retención de datos:

Acceso cero de los operadores (ZOA) significa que los operadores de AWS no disponen de ningún mecanismo técnico para iniciar sesión en los sistemas de cómputo subyacentes de Mantle ni acceder allí a los datos de los clientes. Consulta la documentación de AWS sobre el diseño de ZOA.
Retención cero de datos (ZDR) significa que AWS no guarda los datos de las solicitudes ni de las respuestas en almacenamiento persistente cuando el modo de retención efectivo es none.

Configurar store: false no garantiza la ZDR. En las solicitudes a la API Responses cuyo modo de retención efectivo es none, AWS rechaza store: true y el modo en segundo plano no está disponible.

En el caso de los modelos de OpenAI en Amazon Bedrock, AWS no comparte con OpenAI el contenido de las solicitudes ni de las respuestas cuando el modo de retención efectivo es default o none. Consulta la documentación de AWS sobre la retención de datos para conocer los modos disponibles, los requisitos para usarlos y cómo configurarlos en una cuenta o un proyecto. Consulta la documentación sobre la detección de abusos en Amazon Bedrock para conocer los requisitos de retención y las excepciones de cada modelo.

Si AWS detecta posible material de abuso sexual infantil (MASI) en una imagen de entrada, puede trasladar la entrada o salida marcada fuera del entorno ZOA, almacenarla y revisarla únicamente para determinar si se trata de MASI. AWS también puede presentar un informe ante las autoridades nacionales.

Autenticación y operaciones

Tu administrador de AWS controla el acceso a la cuenta, a los modelos y a las funciones. Consulta la documentación de AWS sobre claves de API para saber cómo crear credenciales y gestionar su ciclo de vida, y la documentación de IAM para obtener información sobre identidades y permisos. Los ejemplos del SDK de OpenAI en esta página muestran cómo proporcionar esas credenciales. Los permisos de AWS se configuran por separado.

Precios

AWS factura el uso de Amazon Bedrock. En las regiones comerciales, los precios de Bedrock coinciden con los que cobra OpenAI directamente por servicios equivalentes. Si usas un servicio específico de una región en Bedrock, se te cobrará la misma tarifa que por el procesamiento regional en la API de OpenAI. El uso de Bedrock está sujeto a las condiciones comerciales de Amazon.

Consulta los precios de la API para conocer las tarifas que cobra OpenAI directamente. Para conocer las tarifas de Bedrock, los niveles de servicio disponibles y las opciones de facturación, consulta los precios de Amazon Bedrock y la tarjeta del modelo correspondiente.

Bedrock Managed Agents

Para obtener información sobre las sesiones de agentes administradas en AWS, consulta Bedrock Managed Agents.

Próximos pasos

Para configurar ChatGPT Work y Codex, consulta Cómo usar ChatGPT Work y Codex con Amazon Bedrock.

Sugerencias

Primeros pasos

Conceptos fundamentales

SDK y CLI

Proveedores de servicios en la nube

Recursos

API heredadas

Elige un modelo

Texto y código

Redacción de prompts

Razonamiento

Imágenes

Tiempo real y audio

Modelos especializados

API de agentes

Agents SDK

ChatKit

Búsqueda y recuperación de información

Conecta herramientas y datos

Crea flujos de trabajo con herramientas

Computadora y código

Multimedia

GPT-Live

Realtime API

Desarrollar aplicaciones de voz

Conexiones

Procesamiento de audio

Pasa a producción

Rendimiento y calidad

Evaluación

Costo y rendimiento

Seguridad y gobernanza

Infraestructura y acceso

Operaciones

Conceptos básicos

Planificación

Desarrollo

Pruebas y publicación

Especificaciones de conversión

Guías

Recursos

Identidad

Uso del plan de ChatGPT

Guías

Carga de archivos

API

Medición

API para anunciantes

Referencia de la API

Primeros pasos

Primeros pasos

Fundamentos

Explorar

Disponible en

Versiones

Flujos de trabajo

Capacidades

Sites

dots

ChatGPT Espacio

Referencia

Personalización

Archivo de configuración

Configuración de agentes

Ampliar las funciones de ChatGPT y Codex

Linux

Windows

Flujos de trabajo de desarrollo

Ampliar funciones y automatizar

Entornos

Codex Cloud

Desarrollar con Codex

Integraciones de terceros

Referencia

Permisos

Codex Security

Ciberseguridad

Primeros pasos

Configuración de funciones

Identidad y acceso