View a markdown version of this page

Chiavi API - Amazon Bedrock
Genera una chiave API a breve termineGenera una chiave API a lungo termineUso di una chiave APIAuto-refresh chiavi a breve termineModifica le autorizzazioniChiavi compromesseAutorizzazioni di controllo

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Chiavi API

Le chiavi API di Amazon Bedrock consentono di autenticare le richieste API utilizzando un token bearer anziché credenziali. AWS Esistono due tipi di elenchi:

  • Short-term— Dura fino a 12 ore (o la durata della sessione, a seconda di quale dei due sia più breve). Eredita le autorizzazioni dal principale IAM utilizzato per generarlo. Consigliato per l'uso in produzione.

  • Long-term— Dura fino a una data di scadenza configurata. Crea un utente IAM con policy allegate. Consigliato solo per l'esplorazione.

Nota

Tutte le chiamate API vengono registrate. AWS CloudTrail Le chiavi API vengono passate come intestazioni di autorizzazione e non vengono registrate.

Genera una chiave API a breve termine

Scegli la scheda relativa al metodo che preferisci, quindi segui la procedura:

Console

  1. Accedi a Console di gestione AWS con un'identità IAM che dispone delle autorizzazioni per utilizzare la console Amazon Bedrock. Quindi, apri la console Amazon Bedrock all'indirizzo https://console.aws.amazon.com/bedrock.

  2. Nel riquadro di navigazione a sinistra, seleziona Chiavi API.

  3. Nella scheda Chiavi Short-term API, scegli Genera chiavi API a breve termine.

La chiave scade alla scadenza della sessione della console (massimo 12 ore). Per generare una chiave per una regione diversa, cambia prima regione nella console.

Python

Installa il generatore di token:

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

Installa il generatore di token:

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

Aggiungi la dipendenza (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 chiave API a lungo termine

avvertimento

Long-term le chiavi sono solo per l'esplorazione. Per la produzione, utilizzate chiavi a breve termine. Per ulteriori informazioni, consulta Alternative alle chiavi di accesso a lungo termine.

Scegli la scheda relativa al metodo che preferisci, quindi segui la procedura:

Console

  1. Accedi a Console di gestione AWS con un'identità IAM che dispone delle autorizzazioni per utilizzare la console Amazon Bedrock. Quindi, apri la console Amazon Bedrock all'indirizzo https://console.aws.amazon.com/bedrock.

  2. Nel riquadro di navigazione a sinistra, seleziona Chiavi API.

  3. Nella scheda Chiavi Long-term API, scegli Genera chiavi API a lungo termine.

  4. Scegli una data di scadenza e, facoltativamente, aggiungi le autorizzazioni in Autorizzazioni avanzate.

  5. Scegliere Generate (Genera).

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}

ServiceApiKeyValueNella risposta c'è la tua chiave API.

Per disattivare o eliminare la chiave in un secondo momento, usa la ServiceSpecificCredentialId risposta:

# 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 di una chiave API

Imposta la chiave come variabile di ambiente:

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

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

Oppure passala direttamente nell'Authorizationintestazione:

Authorization: Bearer ${api-key}
Esempio: fai una richiesta Converse

scegli la scheda relativa al tuo metodo preferito, quindi segui i passaggi:

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 chiavi a breve termine

Per applicazioni di lunga durata, chiamate il generatore di token prima di ogni richiesta. Restituisce un token memorizzato nella cache se ancora valido o ne genera uno nuovo 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)});

Per altri esempi, consulta la documentazione del generatore di token: Python | Javascript | Java.

Modifica le autorizzazioni

Una chiave API a lungo termine è associata a un utente IAM. Per modificarne le autorizzazioni, modifica le politiche allegate a quell'utente. Vedi Aggiungere e rimuovere le autorizzazioni di identità IAM.

Dalla console: vai su Chiavi API > Chiavi Long-term API > seleziona la tua chiave > Gestisci nella console IAM.

Chiavi compromesse

Se una chiave è compromessa, intraprendi una delle seguenti azioni:

Azione Tipo di chiavi In che modo
disattivare Long-term Console: chiavi API > seleziona chiave > Azioni > Disattiva. API: UpdateServiceSpecificCredential conStatus=Inactive.
Reimposta Long-term Console: Azioni > Chiave di ripristino. API:ResetServiceSpecificCredential.
Elimina Long-term Console: Azioni > Elimina. API:DeleteServiceSpecificCredential.
Invalidare la sessione Short-term Allega una policy IAM all'identità che bedrock:CallWithBearerToken nega o invalida la sessione utilizzata per generare la chiave.

Controlla chi può generare e utilizzare le chiavi API

Due azioni IAM controllano la generazione e l'utilizzo delle chiavi API:

  • iam:CreateServiceSpecificCredential— Controlla la generazione di chiavi a lungo termine. Usa il tasto iam:ServiceSpecificCredentialAgeDays condizionale per limitare la scadenza (ad esempio, massimo 90 giorni).

  • bedrock:CallWithBearerToken— Controlla l'utilizzo di qualsiasi chiave API. Utilizza la chiave di bedrock:bearerTokenType condizione con valori SHORT_TERM o LONG_TERM per scegliere come target tipi di chiave specifici.

Esempio: impedire a un'identità di utilizzare qualsiasi chiave API

Allega questa politica all'identità:

{
    "Version": "2012-10-17", 
    "Statement": [
        {
            "Effect": "Deny",
            "Action": "bedrock:CallWithBearerToken",
            "Resource": "*"
        }
    ]
}
Esempio: consente solo chiavi di breve durata (max 90 giorni)

Allega questa politica all'identità:

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

Per esempi di policy più dettagliati, vediRiferimento alle chiavi API.