Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Claves de API
<a name="api-keys"></a>

Las claves de API de Amazon Bedrock le permiten autenticar las solicitudes de API mediante un token portador en lugar de credenciales. AWS Hay dos tipos:
+ **Short-term**— Dura hasta 12 horas (o la duración de la sesión, lo que sea más corto). Hereda los permisos del principal de IAM utilizado para generarla. Se recomienda para uso en producción.
+ **Long-term**— Dura hasta una fecha de caducidad configurada. Crea un usuario de IAM con políticas adjuntas. Se recomienda solo para la exploración.

**nota**  
Todas las llamadas a la API están registradas AWS CloudTrail. Las claves de API se transmiten como encabezados de autorización y no se registran.

## Genera una clave de API a corto plazo
<a name="api-keys-gen-short"></a>

Elija la pestaña del método que prefiera y siga estos pasos:

------
#### [ Console ]

1. Inicie sesión Consola de administración de AWS con una identidad de IAM que tenga permisos para usar la consola Amazon Bedrock. A continuación, abra la consola Amazon Bedrock en [https://console.aws.amazon.com/bedrock](https://console.aws.amazon.com/bedrock).

1. En el panel de navegación izquierdo, seleccione **Claves de API**.

1. En la pestaña **Claves de Short-term API, selecciona Generar claves** **de API a corto plazo**.

La clave caduca cuando caduca la sesión de la consola (máximo 12 horas). Para generar una clave para una región diferente, primero cambia de región en la consola.

------
#### [ Python ]

Instala el generador de fichas:

```
pip install aws-bedrock-token-generator
```

Genera un token:

```
from aws_bedrock_token_generator import provide_token

token = provide_token()
print(f"Token: {token}")
```

------
#### [ Javascript ]

Instala el generador de fichas:

```
npm install @aws/bedrock-token-generator
```

Genera un token:

```
import { getTokenProvider } from "@aws/bedrock-token-generator";

const provideToken = getTokenProvider();
const token = await provideToken();
console.log(`Bearer Token: ${token}`);
```

------
#### [ Java ]

Agrega la dependencia (Maven):

```
<dependency>
    <groupId>software.amazon.bedrock</groupId>
    <artifactId>aws-bedrock-token-generator</artifactId>
    <version>1.1.0</version>
</dependency>
```

Genera un token:

```
import software.amazon.bedrock.token.BedrockTokenGenerator;

BedrockTokenGenerator tokenGenerator = BedrockTokenGenerator.builder().build();
String token = tokenGenerator.getToken();
```

------

## Genera una clave de API a largo plazo
<a name="api-keys-gen-long"></a>

**aviso**  
Long-term las claves son solo para exploración. Para la producción, utilice claves de corta duración. Para obtener más información, consulte [Alternativas a las claves de acceso a largo plazo](https://docs.aws.amazon.com/IAM/latest/UserGuide/security-creds-programmatic-access.html#security-creds-alternatives-to-long-term-access-keys).

Elija la pestaña del método que prefiera y siga estos pasos:

------
#### [ Console ]

1. Inicie sesión Consola de administración de AWS con una identidad de IAM que tenga permisos para usar la consola Amazon Bedrock. A continuación, abra la consola Amazon Bedrock en [https://console.aws.amazon.com/bedrock](https://console.aws.amazon.com/bedrock).

1. En el panel de navegación izquierdo, seleccione **Claves de API**.

1. En la pestaña **Claves de Long-term API, selecciona Generar claves** **de API a largo plazo**.

1. Elige una fecha de caducidad y, si lo deseas, añade permisos en **Permisos avanzados**.

1. Seleccione **Generar**.

------
#### [ CLI ]

```
# Create an IAM user
aws iam create-user --user-name bedrock-api-user

# Attach permissions
aws iam attach-user-policy --user-name bedrock-api-user \
    --policy-arn arn:aws:iam::aws:policy/AmazonBedrockLimitedAccess

# Generate the API key (replace NUMBER-OF-DAYS)
aws iam create-service-specific-credential \
    --user-name bedrock-api-user \
    --service-name bedrock.amazonaws.com \
    --credential-age-days {{${NUMBER-OF-DAYS}}}
```

`ServiceApiKeyValue`En la respuesta aparece tu clave de API.

Para desactivar o eliminar la clave más adelante, usa la siguiente información `ServiceSpecificCredentialId` de la respuesta:

```
# Deactivate the key
aws iam update-service-specific-credential \
    --user-name bedrock-api-user \
    --service-specific-credential-id {{${ServiceSpecificCredentialId}}} \
    --status Inactive

# Delete the key permanently
aws iam delete-service-specific-credential \
    --user-name bedrock-api-user \
    --service-specific-credential-id {{${ServiceSpecificCredentialId}}}
```

------
#### [ Python ]

```
import boto3

iam_client = boto3.client("iam")

# Create IAM user
iam_client.create_user(UserName="bedrock-api-user")

# Attach permissions
iam_client.attach_user_policy(
    UserName="bedrock-api-user",
    PolicyArn="arn:aws:iam::aws:policy/AmazonBedrockLimitedAccess"
)

# Generate API key
response = iam_client.create_service_specific_credential(
    UserName="bedrock-api-user",
    ServiceName="bedrock.amazonaws.com",
    CredentialAgeDays=30
)
api_key = response["ServiceSpecificCredential"]["ServiceApiKeyValue"]
print(api_key)
```

------

## Uso de una clave de API
<a name="api-keys-use"></a>

Configura la clave como una variable de entorno:

```
# macOS/Linux
export AWS_BEARER_TOKEN_BEDROCK={{${api-key}}}

# Windows
setx AWS_BEARER_TOKEN_BEDROCK "{{${api-key}}}"
```

O pásala directamente al `Authorization` encabezado:

```
Authorization: Bearer {{${api-key}}}
```

**Ejemplo: haz una solicitud de Converse**  
elige la pestaña del método que prefieras y, a continuación, sigue los pasos:

------
#### [ cURL ]

```
curl -X POST "https://bedrock-runtime.us-east-1.amazonaws.com/model/us.anthropic.claude-sonnet-4-6/converse" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $AWS_BEARER_TOKEN_BEDROCK" \
  -d '{
    "messages": [{"role": "user", "content": [{"text": "Hello"}]}]
  }'
```

------
#### [ Python (boto3) ]

```
import os
import boto3

os.environ['AWS_BEARER_TOKEN_BEDROCK'] = "{{${api-key}}}"

client = boto3.client("bedrock-runtime", region_name="us-east-1")
response = client.converse(
    modelId="us.anthropic.claude-sonnet-4-6",
    messages=[{"role": "user", "content": [{"text": "Hello"}]}]
)
```

------

## Auto-refresh claves de corto plazo
<a name="api-keys-auto-refresh"></a>

Para aplicaciones de larga duración, llama al generador de fichas antes de cada solicitud. Devuelve un token en caché si sigue siendo válido o genera uno nuevo automáticamente:

------
#### [ Python ]

```
from aws_bedrock_token_generator import provide_token
import requests

url = "https://bedrock-runtime.us-west-2.amazonaws.com/model/us.anthropic.claude-sonnet-4-6/converse"
payload = {"messages": [{"role": "user", "content": [{"text": "Hello"}]}]}

# Call provide_token() before each request — it handles caching/refresh
token = provide_token()
headers = {"Content-Type": "application/json", "Authorization": f"Bearer {token}"}
response = requests.post(url, headers=headers, json=payload)
print(response.json())
```

------
#### [ Javascript ]

```
import { getTokenProvider } from "@aws/bedrock-token-generator";

const provideToken = getTokenProvider();

const url = "https://bedrock-runtime.us-east-1.amazonaws.com/model/us.anthropic.claude-sonnet-4-6/converse";
const payload = {messages: [{role: "user", content: [{text: "Hello"}]}]};

// provideToken() handles caching/refresh automatically
const headers = {
    "Content-Type": "application/json",
    "Authorization": `Bearer ${await provideToken()}`
};
await fetch(url, {method: 'POST', headers, body: JSON.stringify(payload)});
```

------

Para ver más ejemplos, consulta la documentación del generador de tokens: [Python](https://github.com/aws/aws-bedrock-token-generator-python/blob/main/README.md) \| [Javascript](https://github.com/aws/aws-bedrock-token-generator-js/blob/main/README.md) \| [Java](https://github.com/aws/aws-bedrock-token-generator-java/blob/main/README.md).

## Modificar los permisos
<a name="api-keys-modify"></a>

Una clave de API de larga duración está asociada a un usuario de IAM. Para cambiar sus permisos, modifique las políticas asociadas a ese usuario. Consulte [Añadir y eliminar permisos de identidad de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html).

Desde la consola: vaya a Claves de **API > Claves** de **Long-term API** > seleccione su clave > **Administrar en la consola de IAM**.

## Claves comprometidas
<a name="api-keys-compromised"></a>

Si una clave está comprometida, lleve a cabo una de las siguientes acciones:


| Action | Tipo de clave | Cómo | 
| --- | --- | --- | 
| Desactivación | Long-term | Consola: claves de API > tecla de selección > Acciones > Desactivar. API: UpdateServiceSpecificCredential conStatus=Inactive. | 
| Restablecer | Long-term | Consola: Acciones > Restablecer clave. API:ResetServiceSpecificCredential. | 
| Eliminar | Long-term | Consola: Acciones > Eliminar. API:DeleteServiceSpecificCredential. | 
| Invalidar sesión | Short-term | Adjunte una política de IAM a la identidad que deniegue bedrock:CallWithBearerToken o invalide la sesión utilizada para generar la clave. | 

## Controle quién puede generar y usar las claves de API
<a name="api-keys-control"></a>

Dos acciones de IAM controlan la generación y el uso de las claves de la API:
+ `iam:CreateServiceSpecificCredential`— Controla la generación de claves a largo plazo. Utilice la clave de `iam:ServiceSpecificCredentialAgeDays` condición para limitar la caducidad (por ejemplo, un máximo de 90 días).
+ `bedrock:CallWithBearerToken`— Controla el uso de cualquier clave de API. Usa la clave de `bedrock:bearerTokenType` condición con valores `SHORT_TERM` o `LONG_TERM` para dirigirte a tipos de clave específicos.

**Ejemplo: impedir que una identidad utilice cualquier clave de API**  
Adjunta esta política a la identidad:

```
{
    "Version": "2012-10-17", 		 	 	 
    "Statement": [
        {
            "Effect": "Deny",
            "Action": "bedrock:CallWithBearerToken",
            "Resource": "*"
        }
    ]
}
```

**Ejemplo: permita solo claves de corta duración (máximo 90 días)**  
Adjunte esta política a la identidad:

```
{
    "Version": "2012-10-17", 		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": "iam:CreateServiceSpecificCredential",
            "Resource": "*",
            "Condition": {
                "NumericLessThanEquals": {
                    "iam:ServiceSpecificCredentialAgeDays": "90"
                },
                "StringEquals": {
                    "iam:ServiceSpecificCredentialServiceName": "bedrock.amazonaws.com"
                }
            }
        }
    ]
}
```

Para ver ejemplos de políticas más detallados, consulte[Referencia de claves de API](api-keys-reference.md).