

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Génération d’une clé d’API Amazon Bedrock
<a name="api-keys-generate"></a>

Vous pouvez générer une clé d'API Amazon Bedrock à l'aide de l'API AWS Management Console ou de l' AWS API. Nous vous recommandons d'utiliser le AWS Management Console pour générer facilement une clé d'API Amazon Bedrock en quelques étapes.

**Avertissement**  
Nous vous recommandons vivement de restreindre l’utilisation des clés d’API Amazon Bedrock pour explorer Amazon Bedrock. Lorsque vous serez prêt à intégrer Amazon Bedrock dans des applications présentant des exigences de sécurité plus strictes, vous devriez passer à des informations d’identification à court terme. Pour plus d’informations, consultez [Alternatives aux clés d’accès à long terme](https://docs.aws.amazon.com/IAM/latest/UserGuide/security-creds-programmatic-access.html#security-creds-alternatives-to-long-term-access-keys) dans le Guide de l’utilisateur IAM.

**Topics**
+ [Génération d’une clé d’API Amazon Bedrock à l’aide de la console](#api-keys-generate-console)
+ [Génération d’une clé d’API Amazon Bedrock à long terme à l’aide de l’API](#api-keys-generate-api-long-term)
+ [Générez une clé d’API Amazon Bedrock à court terme à l’aide d’une bibliothèque cliente](#api-keys-generate-short-term)
+ [Configuration de l’actualisation automatique des clés d’API Amazon Bedrock à court terme](#api-keys-refresh-short-term)

## Génération d’une clé d’API Amazon Bedrock à l’aide de la console
<a name="api-keys-generate-console"></a>

Pour générer une clé d’API Amazon Bedrock à l’aide de la console, procédez comme suit :

1. Connectez-vous au AWS Management Console avec une identité IAM autorisée à utiliser la console Amazon Bedrock. Ouvrez ensuite la console Amazon Bedrock à l'adresse [https://console.aws.amazon.com/bedrock.](https://console.aws.amazon.com/bedrock)

1. Dans le panneau de navigation de gauche, sélectionnez **Clés d’API**.

1. Générez l’un des types de clés suivants :
   + **Clé d’API à court terme** : dans l’onglet **Clés d’API à court terme**, choisissez **Générer des clés d’API à court terme**. La clé expire à l'expiration de votre session de console (et pas plus de 12 heures) et vous permet de passer des appels vers la console à partir de Région AWS laquelle vous l'avez générée. Vous pouvez modifier la région directement dans la clé générée.
   + **Clé d’API à long terme** : dans l’onglet **Clés d’API à long terme**, choisissez **Générer des clés d’API à long terme**.

     1. Dans la section **Expiration de la clé API**, choisissez un délai au terme duquel la clé expirera.

     1. (Facultatif) Par défaut, la politique [AmazonBedrockLimitedAccess](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonBedrockLimitedAccess) AWS gérée, qui donne accès aux principales opérations de l'API Amazon Bedrock, est attachée à l'utilisateur IAM associé à la clé. Pour sélectionner d’autres stratégies à associer à l’utilisateur, développez la section **Autorisations avancées** et sélectionnez les stratégies que vous souhaitez ajouter.

     1. Choisissez **Générer**.
**Avertissement**  
Nous vous recommandons vivement de restreindre l’utilisation des clés d’API Amazon Bedrock pour explorer Amazon Bedrock. Lorsque vous serez prêt à intégrer Amazon Bedrock dans des applications présentant des exigences de sécurité plus strictes, vous devriez passer à des informations d’identification à court terme. Pour plus d’informations, consultez [Alternatives aux clés d’accès à long terme](https://docs.aws.amazon.com/IAM/latest/UserGuide/security-creds-programmatic-access.html#security-creds-alternatives-to-long-term-access-keys) dans le Guide de l’utilisateur IAM.



## Génération d’une clé d’API Amazon Bedrock à long terme à l’aide de l’API
<a name="api-keys-generate-api-long-term"></a>

Les étapes générales de création d’une clé d’API Amazon Bedrock à long terme dans l’API sont les suivantes :

1. Créez un utilisateur IAM en envoyant une [CreateUser](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateUser.html)demande avec un point de terminaison [IAM](https://docs.aws.amazon.com/general/latest/gr/iam-service.html).

1. Attachez-le [AmazonBedrockLimitedAccess](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonBedrockLimitedAccess)à l'utilisateur IAM en envoyant une [AttachUserPolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_AttachUserPolicy.html)demande avec un point de terminaison [IAM](https://docs.aws.amazon.com/general/latest/gr/iam-service.html). Vous pouvez répéter cette étape pour associer d’autres stratégies gérées ou personnalisées selon les besoins à l’utilisateur.
**Note**  
Pour des raisons de sécurité optimales, nous vous recommandons vivement d’associer des politiques IAM à l’utilisateur IAM afin de restreindre l’utilisation des clés d’API Amazon Bedrock. Pour des exemples de stratégies limitées dans le temps et de restriction des adresses IP autorisées à utiliser la clé, consultez [Contrôler l’utilisation des clés d’accès en associant une politique en ligne à un utilisateur IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access-keys_inline-policy.html).

1. Générez la clé d'API Amazon Bedrock à long terme en envoyant une [CreateServiceSpecificCredential](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateServiceSpecificCredential.html.html)demande avec un point de [terminaison IAM](https://docs.aws.amazon.com/general/latest/gr/iam-service.html) et en spécifiant `bedrock.amazonaws.com` comme. `ServiceName`
   + La `ServiceApiKeyValue` renvoyée dans la réponse est votre clé d’API Amazon Bedrock à long terme.
   + La `ServiceSpecificCredentialId` renvoyée dans la réponse peut être utilisée pour effectuer des opérations d’API liées à la clé.

Pour savoir comment générer une clé d’API Amazon Bedrock à long terme, choisissez l’onglet correspondant à votre méthode préférée, puis suivez les étapes :

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

Pour créer une clé d'API Amazon Bedrock à long terme, vous devez utiliser les opérations d' Gestion des identités et des accès AWS API. Tout d’abord, vérifiez que vous remplissez les conditions requises :

**Prérequis**  
Assurez-vous que votre configuration permet de AWS CLI reconnaître automatiquement vos AWS informations d'identification. Pour en savoir plus, consultez [Configuration des paramètres pour l’ AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html).

Ouvrez une fenêtre de terminal et exécutez les commandes suivantes :

1. Créez un utilisateur IAM. Vous pouvez remplacer le nom par celui de votre choix :

   ```
   aws iam create-user --user-name bedrock-api-user
   ```

1. Attachez-le [AmazonBedrockLimitedAccess](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonBedrockLimitedAccess)à l'utilisateur. Vous pouvez répéter cette étape avec toutes ARNs les autres politiques AWS gérées ou personnalisées que vous souhaitez ajouter à la clé d'API :

   ```
   aws iam attach-user-policy --user-name bedrock-api-user --policy-arn arn:aws:iam::aws:policy/AmazonBedrockLimitedAccess
   ```

1. Créez la clé d'API Amazon Bedrock à long terme, en la *\$1\$1NUMBER-OF-DAYS\$1* remplaçant par le nombre de jours pendant lesquels vous souhaitez que la clé dure :

   ```
   aws iam create-service-specific-credential \
       --user-name bedrock-api-user \
       --service-name bedrock.amazonaws.com \
       --credential-age-days ${NUMBER-OF-DAYS}
   ```

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

Pour créer une clé d'API Amazon Bedrock à long terme, vous devez utiliser les opérations d' Gestion des identités et des accès AWS API. Tout d’abord, vérifiez que vous remplissez les conditions requises :

**Prérequis**  
Assurez-vous que votre configuration permet à Python de reconnaître automatiquement vos AWS informations d'identification. Pour en savoir plus, consultez [Configuration des paramètres pour l’ AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html).

Exécutez le script suivant pour créer un utilisateur IAM, associer des autorisations pour effectuer des actions Amazon Bedrock et générer une clé d’API Amazon Bedrock à long terme à associer à l’utilisateur :

```
import boto3
from datetime import datetime, timedelta

# Replace with name for your IAM user
username = "bedrock-api-user"
# Add any AWS-managed or custom policies that you want to the user
bedrock_policies = [
    "arn:aws:iam::aws:policy/AmazonBedrockLimitedAccess",        # Limited access
#    "arn:aws:iam::aws:policy/AmazonBedrockMarketplaceAccess",   # Optional: Access to Amazon Bedrock Marketplace actions
]
# Set the key expiration time to a number of your choice
expiration_time_in_days = 30

iam_client = boto3.client("iam")
    
# Create IAM user
user = iam_client.create_iam_user(username)

# Attach policies to user
for policy_arn in bedrock_policies:
    iam_client.attach_managed_policy(username, policy_arn)

# Create long-term Amazon Bedrock API key and return it
service_credentials = iam_client.create_service_specific_credential(
    user_name=username, 
    service_name="bedrock",
    credential_age_days=expiration_time_in_days
) 
api_key = service_credentials["ServiceApiKeyValue"]
print(api_key)
```

------

## Générez une clé d’API Amazon Bedrock à court terme à l’aide d’une bibliothèque cliente
<a name="api-keys-generate-short-term"></a>

Les clés à court terme possèdent les propriétés suivantes :
+ Valables pour la plus courte des valeurs suivantes :
  + 12 heures
  + Durée de la session générée par le principal IAM utilisé pour générer la clé.
+ Héritez des autorisations associées au principal utilisé pour générer la clé.
+ Peut être utilisé uniquement dans la AWS région à partir de laquelle vous l'avez généré.

Pour les applications de longue durée, la bibliothèque [aws-bedrock-token-generator](https://github.com/aws/aws-bedrock-token-generator-js/blob/main/README.md)cliente peut créer de nouvelles clés d'API à court terme Amazon Bedrock selon les besoins lorsque les informations d'identification sont actualisées. Pour de plus amples informations, veuillez consulter [Configuration de l’actualisation automatique des clés d’API Amazon Bedrock à court terme](#api-keys-refresh-short-term).

**Conditions préalables**
+ Assurez-vous que le principal IAM que vous utilisez pour générer la clé est configuré avec les autorisations appropriées pour utiliser Amazon Bedrock. À des fins d'expérimentation, vous pouvez associer la [AmazonBedrockLimitedAccess](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonBedrockLimitedAccess)politique AWS-managed au principal. Vous pouvez vous référer aux [meilleures pratiques de sécurité d’IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) pour protéger vos informations d’identification.
+ Assurez-vous que votre configuration permet à Python de reconnaître automatiquement vos AWS informations d'identification. La méthode par défaut par laquelle les informations d’identification sont extraites suit une hiérarchie définie. Vous pouvez consulter la hiérarchie d'un SDK ou d'un outil spécifique sur les fournisseurs d'[informations d'identification standardisés AWS SDKs et Tools](https://docs.aws.amazon.com/sdkref/latest/guide/standardized-credentials.html).
+ Installez le générateur de jetons Amazon Bedrock. Choisissez l’onglet correspondant à votre méthode préférée, puis suivez les étapes :

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

Ouvrez un terminal et exécutez la commande suivante :

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

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

Ouvrez un terminal et exécutez la commande suivante :

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

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

Si vous utilisez Maven, ajoutez la dépendance suivante à votre fichier `pom.xml` :

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

Si vous utilisez Gradle, ajoutez ce qui suit à votre `build.gradle` :

```
implementation 'software.amazon.bedrock:aws-bedrock-token-generator:1.1.0'
```

------

**Exemples**  
Pour voir des exemples d’utilisation du générateur de jetons pour générer une clé d’API Amazon Bedrock à court terme avec vos informations d’identification par défaut dans différentes langues, choisissez l’onglet correspondant à votre méthode préférée, puis suivez les étapes :

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

```
from aws_bedrock_token_generator import provide_token

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

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

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

// Create a token provider that uses default credentials and region providers.
// You can configure it to use other credential providers.
const provideToken = getTokenProvider();

async function example() {
    
  const token = await provideToken();

  // Use the token for API calls. The token has a default expiration of 12 hour.
  // If the expiresInSeconds parameter is specified during token creation, the 
  // expiration can be configured up to a maximum of 12 hours. However, the actual 
  // token validity period will always be the minimum of the requested expiration 
  // time and the AWS credentials' expiry time
  console.log(`Bearer Token: ${token}`);
}
```

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

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

// Credentials and region will be picked up from the default provider chain
BedrockTokenGenerator tokenGenerator = BedrockTokenGenerator.builder().build();
tokenGenerator.getToken();
```

------

Pour voir d’autres exemples de différents cas d’utilisation lors de la génération de jetons, consultez les liens suivants :
+ [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)

## Configuration de l’actualisation automatique des clés d’API Amazon Bedrock à court terme
<a name="api-keys-refresh-short-term"></a>

Vous pouvez créer un script à l’aide du package `aws-bedrock-token-generator` pour régénérer par programmation une nouvelle clé à court terme chaque fois que votre clé actuelle a expiré. Tout d’abord, vérifiez que vous remplissez les conditions préalables énoncées dans [Générez une clé d’API Amazon Bedrock à court terme à l’aide d’une bibliothèque cliente](#api-keys-generate-short-term). Pour voir des exemples de scripts qui extraient un jeton et envoient une requête Converse, choisissez l’onglet correspondant à votre méthode préférée, puis suivez les étapes :

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

```
from aws_bedrock_token_generator import provide_token
import requests

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

    # Create a token provider that uses default credentials and region providers.
    # You can configure it to use other credential providers.
    # https://github.com/aws/aws-bedrock-token-generator-python/blob/main/README.md
    # It can be used for each API call as it is inexpensive.
    token = provide_token()

    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {token}"
    }

    response = requests.post(url, headers=headers, json=payload)
    print(response.json())

if __name__ == "__main__":
    get_new_token()
```

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

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

// Create a token provider that uses default credentials and region providers.
// You can configure it to use other credential providers.
// https://github.com/aws/aws-bedrock-token-generator-js/blob/main/README.md
// This can be created just once. Use await provideToken() to fetch the token
const provideToken = getTokenProvider();

async function example() {
    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" }]
            }
        ]
    };
    const headers = {
        "Content-Type": "application/json",
        // provideToken retrieves a valid token. It can be used for each API call as it is inexpensive.
        "Authorization": `Bearer ${await provideToken()}`
    };
    await fetch(url, {
        method: 'POST',
        headers: headers,
        body: JSON.stringify(payload)
    })
}
```

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

```
package com.amazon.bedrocktoken;

import software.amazon.bedrock.token.BedrockTokenGenerator;

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class GetNewToken {
    public static void main(String[] args) throws Exception {
        // Use default credentials and region from environment/profile chain
        // Create a token generator that uses default credentials and region providers.
        // You can configure it to use other credential providers.
        // https://github.com/aws/aws-bedrock-token-generator-java/blob/main/README.md
        BedrockTokenGenerator tokenGenerator = BedrockTokenGenerator.builder().build();

        // getToken() retrieves a valid token. It can be used for each API call as it is inexpensive.
        String token = tokenGenerator.getToken();

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

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("Content-Type", "application/json")
            .header("Authorization", "Bearer " + token)
            .POST(HttpRequest.BodyPublishers.ofString(payload))
            .build();

        HttpClient client = HttpClient.newHttpClient();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());

        System.out.println(response.body());
    }
}
```

------