View a markdown version of this page

Chaves de API - Amazon Bedrock
Gere uma chave de API de curto prazoGere uma chave de API de longo prazoUsar uma chave de APIAuto-refresh chaves de curto prazoModificar permissõesChaves comprometidasPermissões de controle

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Chaves de API

As chaves de API do Amazon Bedrock permitem que você autentique solicitações de API usando um token de portador em vez de credenciais. AWS Existem dois tipos:

  • Short-term— Dura até 12 horas (ou a duração da sessão, o que for menor). Herda as permissões do diretor do IAM usado para gerá-lo. Recomendado para uso em produção.

  • Long-term— Dura até uma data de expiração configurada. Cria um usuário do IAM com políticas anexadas. Recomendado somente para exploração.

nota

Todas as chamadas de API estão registradas AWS CloudTrail. As chaves de API são passadas como cabeçalhos de autorização e não são registradas.

Gere uma chave de API de curto prazo

Escolha a guia correspondente ao método de sua preferência e siga as etapas:

Console

  1. Faça login no Console de gerenciamento da AWS com uma identidade do IAM que tenha permissões para usar o console Amazon Bedrock. Em seguida, abra o console Amazon Bedrock em https://console.aws.amazon.com/bedrock.

  2. No painel de navegação à esquerda, selecione Chaves de API.

  3. Na guia Chaves de Short-term API, escolha Gerar chaves de API de curto prazo.

A chave expira quando a sessão do console expira (máximo de 12 horas). Para gerar uma chave para uma região diferente, primeiro alterne as regiões no console.

Python

Instale o gerador de tokens:

pip install aws-bedrock-token-generator

Gere um token:

from aws_bedrock_token_generator import provide_token

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

Instale o gerador de tokens:

npm install @aws/bedrock-token-generator

Gere um token:

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

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

Adicione a dependência (Maven):

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

Gere um token:

import software.amazon.bedrock.token.BedrockTokenGenerator;

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

Gere uma chave de API de longo prazo

Atenção

Long-term as chaves são apenas para exploração. Para produção, use chaves de curto prazo. Para obter mais informações, consulte Alternativas às chaves de acesso de longo prazo.

Escolha a guia correspondente ao método de sua preferência e siga as etapas:

Console

  1. Faça login no Console de gerenciamento da AWS com uma identidade do IAM que tenha permissões para usar o console Amazon Bedrock. Em seguida, abra o console Amazon Bedrock em https://console.aws.amazon.com/bedrock.

  2. No painel de navegação à esquerda, selecione Chaves de API.

  3. Na guia Chaves de Long-term API, escolha Gerar chaves de API de longo prazo.

  4. Escolha um prazo de validade e, opcionalmente, adicione permissões em Permissões avançadas.

  5. Escolha Gerar.

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}

ServiceApiKeyValueNa resposta está sua chave de API.

Para desativar ou excluir a chave posteriormente, use o ServiceSpecificCredentialId da resposta:

# 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)

Usar uma chave de API

Defina a chave como uma variável de ambiente:

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

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

Ou passe-o diretamente no Authorization cabeçalho:

Authorization: Bearer ${api-key}
Exemplo: Faça uma solicitação Converse

escolha a guia do seu método preferido e siga as etapas:

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 chaves de curto prazo

Para aplicativos de longa duração, chame o gerador de tokens antes de cada solicitação. Ele retorna um token em cache se ainda for válido ou gera um novo automaticamente:

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 mais exemplos, consulte a documentação do gerador de tokens: Python | Javascript | Java.

Modificar permissões

Uma chave de API de longo prazo está associada a um usuário do IAM. Para alterar suas permissões, modifique as políticas anexadas a esse usuário. Consulte Adicionar e remover permissões de identidade do IAM.

No console: acesse Chaves de API > Chaves de Long-term API > selecione sua chave > Gerenciar no console do IAM.

Chaves comprometidas

Se uma chave for comprometida, execute uma das seguintes ações:

Ação Tipo de chave Como
Desativar Long-term Console: chaves de API > selecione a chave > Ações > Desativar. API: UpdateServiceSpecificCredential comStatus=Inactive.
Redefinir Long-term Console: Ações > Tecla de redefinição. API:ResetServiceSpecificCredential.
Delete Long-term Console: Ações > Excluir. API:DeleteServiceSpecificCredential.
Invalidar sessão Short-term Anexe uma política do IAM à identidade que nega bedrock:CallWithBearerToken ou invalida a sessão usada para gerar a chave.

Controle quem pode gerar e usar chaves de API

Duas ações do IAM controlam a geração e o uso da chave da API:

  • iam:CreateServiceSpecificCredential— Controla a geração de chaves de longo prazo. Use a chave de iam:ServiceSpecificCredentialAgeDays condição para limitar a expiração (por exemplo, no máximo 90 dias).

  • bedrock:CallWithBearerToken— Controla o uso de qualquer chave de API. Use a chave de bedrock:bearerTokenType condição com valores SHORT_TERM ou LONG_TERM para segmentar tipos de chave específicos.

Exemplo: impedir que uma identidade use qualquer chave de API

Anexe esta política à identidade:

{
    "Version": "2012-10-17", 
    "Statement": [
        {
            "Effect": "Deny",
            "Action": "bedrock:CallWithBearerToken",
            "Resource": "*"
        }
    ]
}
Exemplo: permitir somente chaves de curta duração (máximo de 90 dias)

Anexe esta política à identidade:

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

Para obter exemplos de políticas mais detalhados, consulteReferência de chaves de API.