

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Generieren eines API-Schlüssels von Amazon Bedrock
<a name="api-keys-generate"></a>

Sie können einen Amazon Bedrock API-Schlüssel entweder mithilfe der AWS-Managementkonsole oder der AWS API generieren. Wir empfehlen Ihnen, den AWS-Managementkonsole zu verwenden, um mit wenigen Schritten auf einfache Weise einen Amazon Bedrock API-Schlüssel zu generieren.

**Warnung**  
Wir empfehlen dringend, die Verwendung der API-Schlüssel von Amazon Bedrock auf die Erkundung von Amazon Bedrock zu beschränken. Wenn Sie bereit sind, Amazon Bedrock in Anwendungen mit höheren Sicherheitsanforderungen zu integrieren, sollten Sie zu kurzfristigen Anmeldeinformationen wechseln. Weitere Informationen finden Sie unter [Alternativen zu Langzeit-Zugriffsschlüsseln](https://docs.aws.amazon.com/IAM/latest/UserGuide/security-creds-programmatic-access.html#security-creds-alternatives-to-long-term-access-keys) im IAM-Benutzerhandbuch.

**Topics**
+ [Generieren eines API-Schlüssels von Amazon Bedrock mit der Konsole](#api-keys-generate-console)
+ [Generieren eines langfristigen API-Schlüssels von Amazon-Bedrock mit der API](#api-keys-generate-api-long-term)
+ [Generieren eines kurzfristigen API-Schlüssel von Amazon Bedrock mit einer Client-Bibliothek](#api-keys-generate-short-term)
+ [Einrichten der automatischen Aktualisierung der kurzfristigen API-Schlüssel von Amazon Bedrock](#api-keys-refresh-short-term)

## Generieren eines API-Schlüssels von Amazon Bedrock mit der Konsole
<a name="api-keys-generate-console"></a>

Generieren Sie einen API-Schlüssel von Amazon Bedrock mit der Konsole wie folgt:

1. Melden Sie sich bei der AWS-Managementkonsole mit einer IAM-Identität an, die berechtigt ist, die Amazon Bedrock-Konsole zu verwenden. Öffnen Sie dann die Amazon Bedrock-Konsole unter [https://console.aws.amazon.com/bedrock](https://console.aws.amazon.com/bedrock).

1. Wählen Sie im linken Navigationsbereich **API-Schlüssel** aus.

1. Sie können die folgenden Arten von Schlüsseln generieren:
   + **Kurzfristiger API-Schlüssel** – Wählen Sie auf der Registerkarte **Kurzfristige API-Schlüssel** die Option **Kurzfristige API-Schlüssel generieren** aus. Der Schlüssel läuft ab, wenn Ihre Konsolensitzung abläuft (und nicht länger als 12 Stunden) und ermöglicht es Ihnen, Anrufe an die Person zu tätigen AWS-Region , von der aus Sie ihn generiert haben. Sie können die Region direkt im generierten Schlüssel ändern.
   + **Langfristiger API-Schlüssel** – Wählen Sie auf der Registerkarte **Langfristige API-Schlüssel** die Option **Langfristige API-Schlüssel generieren** aus.

     1. Wählen Sie im Abschnitt **Ablauf des API-Schlüssels** einen Zeitraum aus, nach dessen Verstreichen der Schlüssel abläuft.

     1. (Optional) Standardmäßig ist die [AmazonBedrockLimitedAccess](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonBedrockLimitedAccess) AWS-managed Policy, die Zugriff auf die wichtigsten Amazon Bedrock API-Operationen gewährt, an den IAM-Benutzer angehängt, der mit dem Schlüssel verknüpft ist. Um weitere Richtlinien auszuwählen, die dem Benutzer angefügt werden sollen, erweitern Sie den Abschnitt **Erweiterte Berechtigungen** und wählen anschließend die Richtlinien aus, die Sie hinzufügen möchten.

     1. Wählen Sie **Erstellen** aus.
**Warnung**  
Wir empfehlen dringend, die Verwendung der API-Schlüssel von Amazon Bedrock auf die Erkundung von Amazon Bedrock zu beschränken. Wenn Sie bereit sind, Amazon Bedrock in Anwendungen mit höheren Sicherheitsanforderungen zu integrieren, sollten Sie zu kurzfristigen Anmeldeinformationen wechseln. Weitere Informationen finden Sie unter [Alternativen zu Langzeit-Zugriffsschlüsseln](https://docs.aws.amazon.com/IAM/latest/UserGuide/security-creds-programmatic-access.html#security-creds-alternatives-to-long-term-access-keys) im IAM-Benutzerhandbuch.



## Generieren eines langfristigen API-Schlüssels von Amazon-Bedrock mit der API
<a name="api-keys-generate-api-long-term"></a>

Allgemeine Schritte zur Erstellung eines langfristigen API-Schlüssels von Amazon Bedrock in der API:

1. [Erstellen Sie einen IAM-Benutzer, indem Sie eine [CreateUser](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateUser.html)Anfrage mit einem IAM-Endpunkt senden.](https://docs.aws.amazon.com/general/latest/gr/iam-service.html)

1. [Hängen Sie den [AmazonBedrockLimitedAccess](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonBedrockLimitedAccess)an den IAM-Benutzer an, indem Sie eine [AttachUserPolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_AttachUserPolicy.html)Anfrage mit einem IAM-Endpunkt senden.](https://docs.aws.amazon.com/general/latest/gr/iam-service.html) Sie können diesen Schritt wiederholen, um dem Benutzer bei Bedarf weitere verwaltete oder benutzerdefinierte Richtlinien anzufügen.
**Anmerkung**  
Als bewährte Sicherheitsmaßnahme empfehlen wir dringend, dem IAM-Benutzer IAM-Richtlinien anzufügen, um die Verwendung von API-Schlüsseln von Amazon Bedrock einzuschränken. Beispiele für Richtlinien zur zeitlichen Beschränkung und die Beschränkung der IP-Adressen, die den Schlüssel verwenden können, finden Sie unter [Steuern der Verwendung von Zugriffsschlüsseln durch das Anfügen einer Inline-Richtlinie an einen IAM-Benutzer](https://docs.aws.amazon.com/IAM/latest/UserGuide/access-keys_inline-policy.html).

1. Generieren Sie den langfristigen Amazon Bedrock API-Schlüssel, indem [CreateServiceSpecificCredential](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateServiceSpecificCredential.html.html)Sie eine Anfrage mit einem [IAM-Endpunkt](https://docs.aws.amazon.com/general/latest/gr/iam-service.html) senden und `bedrock.amazonaws.com` als. `ServiceName`
   + Der in der Antwort zurückgegebene `ServiceApiKeyValue` ist Ihr langfristiger API-Schlüssel von Amazon Bedrock.
   + Der in der Antwort zurückgegebene `ServiceSpecificCredentialId` kann verwendet werden, um API-Operationen im Zusammenhang mit dem Schlüssel auszuführen.

Um zu erfahren, wie Sie einen langfristigen API-Schlüssel von Amazon Bedrock generieren, wählen Sie die Registerkarte für Ihre bevorzugte Methode aus und befolgen Sie die angegebenen Schritte:

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

Um einen langfristigen Amazon Bedrock API-Schlüssel zu erstellen, verwenden Sie AWS Identity and Access Management API-Operationen. Stellen Sie zunächst sicher, dass die Voraussetzung erfüllt ist:

**Voraussetzung**  
Stellen Sie sicher, dass Ihr Setup es dem ermöglicht, Ihre AWS Anmeldeinformationen automatisch AWS CLI zu erkennen. Weitere Informationen finden Sie unter [Konfigurieren der Einstellungen für die AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html).

Öffnen Sie ein Terminal und führen Sie die folgenden Befehle aus:

1. Erstellen Sie einen IAM-Benutzer. Sie können den Namen durch einen Namen Ihrer Wahl ersetzen:

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

1. Hängen Sie das [AmazonBedrockLimitedAccess](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonBedrockLimitedAccess)an den Benutzer an. Sie können diesen Schritt mit allen anderen AWS verwalteten oder benutzerdefinierten Richtlinien wiederholen, die Sie dem API-Schlüssel hinzufügen möchten: ARNs 

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

1. Erstellen Sie den langfristigen Amazon Bedrock API-Schlüssel und *\$1\$1NUMBER-OF-DAYS\$1* ersetzen Sie ihn durch die Anzahl der Tage, für die der Schlüssel gültig sein soll:

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

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

Um einen langfristigen Amazon Bedrock API-Schlüssel zu erstellen, verwenden Sie AWS Identity and Access Management API-Operationen. Stellen Sie zunächst sicher, dass die Voraussetzung erfüllt ist:

**Voraussetzung**  
Stellen Sie sicher, dass Ihr Setup es Python ermöglicht, Ihre AWS Anmeldeinformationen automatisch zu erkennen. Weitere Informationen finden Sie unter [Konfigurieren der Einstellungen für die AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html).

Führen Sie das folgende Skript aus, um einen IAM-Benutzer zu erstellen, Berechtigungen zur Ausführung von Amazon-Bedrock-Aktionen anzufügen und einen langfristigen API-Schlüssel von Amazon Bedrock zu generieren, der dem Benutzer zugeordnet wird:

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

------

## Generieren eines kurzfristigen API-Schlüssel von Amazon Bedrock mit einer Client-Bibliothek
<a name="api-keys-generate-short-term"></a>

Kurzfristige Schlüssel haben die folgenden Eigenschaften:
+ Sie gelten für den kürzeren der folgenden Werte:
  + 12 Stunden
  + Die Dauer der Sitzung, die vom IAM-Prinzipal generiert wurde, welcher zur Generierung des Schlüssels verwendet wurde.
+ Sie erben die Berechtigungen, die dem Prinzipal zugewiesen sind, der zur Generierung des Schlüssels verwendet wurde.
+ Kann nur in der AWS Region verwendet werden, aus der Sie es generiert haben.

Für Anwendungen mit langer Laufzeit kann die [aws-bedrock-token-generator](https://github.com/aws/aws-bedrock-token-generator-js/blob/main/README.md)Client-Bibliothek bei Bedarf neue kurzfristige API-Schlüssel von Amazon Bedrock erstellen, wenn die Anmeldeinformationen aktualisiert werden. Weitere Informationen finden Sie unter [Einrichten der automatischen Aktualisierung der kurzfristigen API-Schlüssel von Amazon Bedrock](#api-keys-refresh-short-term).

**Voraussetzungen**
+ Stellen Sie sicher, dass der IAM-Prinzipal, den Sie zum Generieren des Schlüssels verwenden, über die richtigen Berechtigungen für die Verwendung von Amazon Bedrock verfügt. Zu Testzwecken können Sie die AWS-managed [AmazonBedrockLimitedAccess](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonBedrockLimitedAccess)Policy an den Principal anhängen. Informationen zum Schutz Ihrer Anmeldeinformationen finden Sie unter [Bewährte Sicherheitsmethoden in IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html).
+ Stellen Sie sicher, dass Ihr Setup es Python ermöglicht, Ihre AWS Anmeldeinformationen automatisch zu erkennen. Die Standardmethode, mit der Anmeldeinformationen abgerufen werden, folgt einer festgelegten Hierarchie. Die Hierarchie für ein bestimmtes SDK oder Tool finden Sie unter [AWS SDKs Standardisierte Anbieter von Anmeldeinformationen in Tools](https://docs.aws.amazon.com/sdkref/latest/guide/standardized-credentials.html).
+ Installieren Sie den Token-Generator von Amazon Bedrock. Wählen Sie die Registerkarte für Ihre bevorzugte Methode aus und befolgen Sie die angegebenen Schritte:

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

Öffnen Sie ein Terminal und führen Sie den folgenden Befehl aus:

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

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

Öffnen Sie ein Terminal und führen Sie den folgenden Befehl aus:

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

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

Wenn Sie Maven verwenden, fügen Sie `pom.xml` die folgende Abhängigkeit hinzu:

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

Wenn Sie Gradle verwenden, fügen `build.gradle` Folgendes hinzu:

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

------

**Beispiele**  
Um Beispiele für die Verwendung des Token-Generators zur Generierung eines kurzfristigen API-Schlüssels von Amazon Bedrock mit Ihren Standardanmeldeinformationen in verschiedenen Sprachen zu sehen, wählen Sie die Registerkarte für Ihre bevorzugte Methode aus und befolgen Sie die angegebenen Schritte:

------
#### [ 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();
```

------

Weitere Beispiele für verschiedene Anwendungsfälle beim Generieren von Token finden Sie unter den folgenden Links:
+ [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)

## Einrichten der automatischen Aktualisierung der kurzfristigen API-Schlüssel von Amazon Bedrock
<a name="api-keys-refresh-short-term"></a>

Mithilfe des `aws-bedrock-token-generator`-Pakets können Sie ein Skript erstellen, um programmgesteuert einen neuen kurzfristigen Schlüssel zu regenerieren, wenn Ihr aktueller abgelaufen ist. Stellen Sie zunächst sicher, dass die Voraussetzungen unter [Generieren eines kurzfristigen API-Schlüssel von Amazon Bedrock mit einer Client-Bibliothek](#api-keys-generate-short-term) erfüllt sind. Um Beispielskripte zu sehen, die ein Token abrufen und eine Converse-Anfrage stellen, wählen Sie die Registerkarte für Ihre bevorzugte Methode aus und befolgen Sie die angegebenen Schritte:

------
#### [ 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());
    }
}
```

------