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
<a name="api-keys"></a>

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
<a name="api-keys-gen-short"></a>

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](https://console.aws.amazon.com/bedrock).

1. Nel riquadro di navigazione a sinistra, seleziona **Chiavi API**.

1. 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
<a name="api-keys-gen-long"></a>

**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](https://docs.aws.amazon.com/IAM/latest/UserGuide/security-creds-programmatic-access.html#security-creds-alternatives-to-long-term-access-keys).

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](https://console.aws.amazon.com/bedrock).

1. Nel riquadro di navigazione a sinistra, seleziona **Chiavi API**.

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

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

1. 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}}}
```

`ServiceApiKeyValue`Nella 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
<a name="api-keys-use"></a>

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'`Authorization`intestazione:

```
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
<a name="api-keys-auto-refresh"></a>

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](https://github.com/aws/aws-bedrock-token-generator-python/blob/main/README.md) \| [Javascript \| Java.](https://github.com/aws/aws-bedrock-token-generator-js/blob/main/README.md)](https://github.com/aws/aws-bedrock-token-generator-java/blob/main/README.md)

## Modifica le autorizzazioni
<a name="api-keys-modify"></a>

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](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html).

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

## Chiavi compromesse
<a name="api-keys-compromised"></a>

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
<a name="api-keys-control"></a>

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, vedi[Riferimento alle chiavi API](api-keys-reference.md).