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 Authentifizierungstokens in Amazon Aurora DSQL
<a name="SECTION_authentication-token"></a>

Um mit einem SQL-Client eine Verbindung zu Amazon Aurora DSQL herzustellen, generieren Sie ein Authentifizierungstoken, das als Passwort verwendet wird. Dieses Token wird nur zur Authentifizierung der Verbindung verwendet. Nachdem die Verbindung hergestellt wurde, bleibt die Verbindung gültig, auch wenn das Authentifizierungstoken abläuft.

Wenn Sie mit der AWS Konsole ein Authentifizierungstoken erstellen AWS CLI, läuft das oder SDKs, das Token standardmäßig automatisch in 15 Minuten ab. Die maximale Dauer beträgt 604.800 Sekunden, also eine Woche. Um von Ihrem Client aus erneut eine Verbindung zu Aurora DSQL herzustellen, können Sie dasselbe Authentifizierungstoken verwenden, sofern es nicht abgelaufen ist, oder Sie können ein neues Token generieren.

Um mit der Generierung eines Tokens zu beginnen, [erstellen Sie eine IAM-Richtlinie](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create-console.html) und [einen Cluster in Aurora DSQL](https://docs.aws.amazon.com/aurora-dsql/latest/userguide/getting-started.html#getting-started-quickstart). Verwenden Sie dann die AWS Konsole oder AWS CLI, AWS SDKs um ein Token zu generieren.

Je nachdem, welche Datenbankrolle Sie für die Verbindung verwenden, benötigen Sie mindestens die unter [Verbindungsaufbau mit Ihrem Cluster mithilfe von IAM](authentication-authorization.md#authentication-authorization-iam-role-connect) aufgeführten IAM-Berechtigungen.

**Topics**
+ [Verwenden Sie die AWS Konsole, um ein Authentifizierungstoken in Aurora DSQL zu generieren](#authentication-token-console)
+ [Wird verwendet AWS CloudShell , um ein Authentifizierungstoken in Aurora DSQL zu generieren](#authentication-token-cloudshell)
+ [Verwenden Sie das AWS CLI , um ein Authentifizierungstoken in Aurora DSQL zu generieren](#authentication-token-cli)
+ [Verwenden Sie das SDKs , um ein Token in Aurora DSQL zu generieren](#authentication-token-sdks)

## Verwenden Sie die AWS Konsole, um ein Authentifizierungstoken in Aurora DSQL zu generieren
<a name="authentication-token-console"></a>

Aurora DSQL authentifiziert Benutzer mit einem Token und nicht mit einem Passwort. Sie können das Token über die Konsole erstellen.

**Generieren eines Authentifizierungstokens**

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Aurora DSQL-Konsole unter[https://console.aws.amazon.com/dsql](https://console.aws.amazon.com/dsql).

1. Wählen Sie die Cluster-ID des Clusters, für den Sie ein Authentifizierungstoken erstellen möchten. Wenn Sie noch keinen Cluster erstellt haben, folgen Sie den Schritten unter [Schritt 1: Erstellen eines Einzelregions-Clusters mit Aurora DSQL](getting-started.md#getting-started-create-cluster) oder [Schritt 4 (optional): Erstellen Sie einen Cluster mit mehreren Regionen](getting-started.md#getting-started-multi-region).

1. Wählen Sie **Verbinden** und dann **Token abrufen** aus.

1. Wählen Sie aus, ob Sie die Verbindung als `admin` oder mit einer [benutzerdefinierten Datenbankrolle](https://docs.aws.amazon.com/aurora-dsql/latest/userguide/authentication-authorization.html#authentication-authorization-iam-role-connect) herstellen möchten.

1. Kopieren Sie das generierte Authentifizierungstoken und verwenden Sie es für [Greifen Sie mithilfe von SQL-Clients auf Aurora DSQL zu](accessing.md#accessing-sql-clients).

Weitere Informationen zu benutzerdefinierten Datenbankrollen und IAM in Aurora DSQL finden Sie unter [Authentifizierung und Autorisierung für Aurora DSQL](authentication-authorization.md).

## Wird verwendet AWS CloudShell , um ein Authentifizierungstoken in Aurora DSQL zu generieren
<a name="authentication-token-cloudshell"></a>

Bevor Sie mit ein Authentifizierungstoken generieren können AWS CloudShell, stellen Sie sicher, dass Sie [einen Aurora DSQL-Cluster erstellen](https://docs.aws.amazon.com/aurora-dsql/latest/userguide/getting-started.html#getting-started-quickstart).

**Um ein Authentifizierungstoken zu generieren, verwenden Sie AWS CloudShell**

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Aurora DSQL-Konsole unter[https://console.aws.amazon.com/dsql](https://console.aws.amazon.com/dsql).

1. Wählen AWS CloudShell Sie unten links in der AWS Konsole.

1. Führen Sie den folgenden Befehl aus, um ein Authentifizierungstoken für die `admin`-Rolle zu generieren. {{us-east-1}}Ersetzen Sie es durch Ihre Region und {{your\_cluster\_endpoint}} durch den Endpunkt Ihres eigenen Clusters. 
**Anmerkung**  
Wenn Sie die Verbindung nicht als `admin` herstellen, verwenden Sie stattdessen `generate-db-connect-auth-token`.

   ```
   aws dsql generate-db-connect-admin-auth-token \
     --expires-in 3600 \
     --region {{us-east-1}} \
     --hostname {{your_cluster_endpoint}}
   ```

   Falls Sie auf Probleme stoßen, finden Sie weitere Informationen unter [Problembehandlung bei IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/troubleshoot.html) und [Wie kann ich Fehler mit einer IAM-Richtlinie beheben, bei denen der Zugriff verweigert wurde oder bei nicht autorisierten Vorgängen?](https://repost.aws/knowledge-center/troubleshoot-iam-policy-issues).

1. Verwenden Sie den folgenden Befehl, um mithilfe von `psql` eine Verbindung zu Ihrem Cluster herzustellen.

   ```
   PGSSLMODE=require \
   psql --dbname postgres \
     --username admin \
     --host cluster_endpoint
   ```

1. Sie sollten nun einen Prompt zur Passworteingab sehen. Kopieren Sie das von Ihnen generierte Token und stellen Sie sicher, dass Sie keine zusätzlichen Leerzeichen oder Zeichen mitkopieren. Fügen Sie es in den folgenden `psql`-Prompt ein.

   ```
   Password for user admin: 
   ```

1. Drücken Sie die **Eingabetaste**. Sie sollten nun einen PostgreSQL-Prompt sehen.

   ```
   postgres=>
   ```

   Wenn Sie die Fehlermeldung „Zugriff verweigert“ erhalten, stellen Sie sicher, dass Ihre IAM-Identität über die entsprechende `dsql:DbConnectAdmin`-Berechtigung verfügt. Wenn Sie über die entsprechende Berechtigung verfügen und weiterhin die Fehlermeldung „Zugriff verweigert“ erhalten, finden Sie weitere Informationen unter [Problembehandlung bei IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/troubleshoot.html) und [Wie kann ich Fehler mit einer IAM-Richtlinie beheben, bei der der Zugriff verweigert wurde oder bei nicht autorisierten Vorgängen?](https://repost.aws/knowledge-center/troubleshoot-iam-policy-issues). 

Weitere Informationen zu benutzerdefinierten Datenbankrollen und IAM in Aurora DSQL finden Sie unter [Authentifizierung und Autorisierung für Aurora DSQL](authentication-authorization.md).

## Verwenden Sie das AWS CLI , um ein Authentifizierungstoken in Aurora DSQL zu generieren
<a name="authentication-token-cli"></a>

Wenn Ihr Cluster `ACTIVE` ist, können Sie mit dem `aws dsql`-Befehl ein Authentifizierungstoken auf der CLI generieren. Sie können eine der folgenden Techniken verwenden:

**Anmerkung**  
Die Token-Generierung ist ein lokaler Vorgang, bei dem die Anfrage mit Ihren aktuellen IAM-Anmeldeinformationen signiert wird. Es wird kein Kontakt hergestellt AWS , um die Anmeldeinformationen zu überprüfen. Wenn Ihre Anmeldeinformationen abgelaufen oder ungültig sind, ist die Token-Generierung trotzdem erfolgreich, aber der Verbindungsversuch schlägt fehl. Stellen Sie sicher, dass Ihre IAM-Anmeldeinformationen gültig sind, bevor Sie ein Token generieren.
+ Wenn Sie eine Verbindung mit der `admin`-Rolle herstellen, verwenden Sie die `generate-db-connect-admin-auth-token`-Option.
+ Wenn Sie eine Verbindung mit einer benutzerdefinierten Datenbankrolle herstellen, verwenden Sie die `generate-db-connect-auth-token`-Option.

Im folgenden Beispiel werden die nachstehenden Attribute verwendet, um ein Authentifizierungstoken für die `admin`-Rolle zu generieren.
+ {{your\_cluster\_endpoint}}— Der Endpunkt des Clusters. Das Attribut folgt dem Format `{{your_cluster_identifier}}.dsql.{{region}}.on.aws` wie im Beispiel `01abc2ldefg3hijklmnopqurstu.dsql.us-east-1.on.aws` gezeigt.
+ {{region}}— Der AWS-Region, wie `us-east-2` oder`us-east-1`.

In den folgenden Beispielen wird die Ablaufzeit für das Token auf 3600 Sekunden (1 Stunde) festgelegt.

------
#### [ Linux and macOS ]

```
aws dsql generate-db-connect-admin-auth-token \
  --region {{region}} \
  --expires-in 3600 \
  --hostname {{your_cluster_endpoint}}
```

------
#### [ Windows ]

```
aws dsql generate-db-connect-admin-auth-token ^
  --region={{region}} ^
  --expires-in=3600 ^
  --hostname={{your_cluster_endpoint}}
```

------

## Verwenden Sie das SDKs , um ein Token in Aurora DSQL zu generieren
<a name="authentication-token-sdks"></a>

Sie können ein Authentifizierungstoken für Ihren Cluster generieren, wenn er sich im Status `ACTIVE` befindet. In den SDK-Beispielen werden die folgenden Attribute verwendet, um ein Authentifizierungstoken für die `admin`-Rolle zu generieren:
+ {{your\_cluster\_endpoint}}(oder{{yourClusterEndpoint}}) — Der Endpunkt Ihres Aurora DSQL-Clusters. Das Benennungsformat ist `{{your_cluster_identifier}}.dsql.{{region}}.on.aws` wie im Beispiel `01abc2ldefg3hijklmnopqurstu.dsql.us-east-1.on.aws`.
+ {{region}}(oder{{RegionEndpoint}}) — Der, AWS-Region in dem sich Ihr Cluster befindet, z. B. `us-east-2` oder`us-east-1`.

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

**Tipp**  
AWS empfiehlt die Verwendung von[Aurora DSQL-Konnektor für PythonÜber den ConnectorWas ist Aurora DSQL-Authentifizierung?FeaturesSchnellstart-AnleitungVoraussetzungenInstallationInstallieren Sie psycopg oder psycopg2 oder asyncpg separatGrundlegende Verwendungpsycopgpsycopg2asyncpgBenutze nur den Hostpsycopgpsycopg2asyncpgNur Cluster-ID verwendenpsycopgpsycopg2asyncpgpsycopgpsycopg2asyncpgVerbindungszeichenfolgePsychopgpsycopg2asyncpgErweiterte KonfigurationPsychopgpsycopg2asyncpgKonfigurationsoptionenVerwenden des Aurora DSQL-Konnektors für Python mit Verbindungspoolingpsycopgpsycopg2asyncpgAuthentifizierungAdmin im Vergleich zu regulären BenutzernBeispielepsycopgpsycopg2asyncpg](SECTION_program-with-dsql-connector-for-python.md), die die Token-Generierung automatisch durchführt.

Sie können das Token wie folgt erstellen:
+ Wenn Sie eine Verbindung mit der `admin` Rolle herstellen, verwenden Sie`generate_db_connect_admin_auth_token`.
+ Wenn Sie eine Verbindung mit einer benutzerdefinierten Datenbankrolle herstellen, verwenden Sie`generate_connect_auth_token`.

```
import boto3

def generate_token(your_cluster_endpoint, region):
    client = boto3.client("dsql", region_name=region)
    # use `generate_db_connect_auth_token` instead if you are not connecting as admin.
    token = client.generate_db_connect_admin_auth_token(your_cluster_endpoint, region)
    print(token)
    return token
```

------
#### [ C\+\+ SDK ]

Sie können das Token wie folgt erstellen:
+ Wenn Sie eine Verbindung mit der `admin` Rolle herstellen, verwenden Sie`GenerateDBConnectAdminAuthToken`.
+ Wenn Sie eine Verbindung mit einer benutzerdefinierten Datenbankrolle herstellen, verwenden Sie`GenerateDBConnectAuthToken`.

```
#include <aws/core/Aws.h>
#include <aws/dsql/DSQLClient.h>
#include <iostream>

using namespace Aws;
using namespace Aws::DSQL;

std::string generateToken(String yourClusterEndpoint, String region) {
    DSQLClientConfiguration clientConfig;
    clientConfig.region = region;
    DSQLClient client{clientConfig};
    std::string token = "";
    
    // If you are not using the admin role to connect, use GenerateDBConnectAuthToken instead
    const auto presignedString = client.GenerateDBConnectAdminAuthToken(yourClusterEndpoint, region);
    if (presignedString.IsSuccess()) {
        token = presignedString.GetResult();
    } else {
        std::cerr << "Token generation failed." << std::endl;
    }

    std::cout << token << std::endl;
    return token;
}

int main() {
    Aws::SDKOptions options;
    Aws::InitAPI(options);
    // Replace with your cluster endpoint and region
    std::string token = generateToken("your_cluster_endpoint.dsql.us-east-1.on.aws", "us-east-1");
    Aws::ShutdownAPI(options);
    return 0;
}
```

------
#### [ JavaScript SDK ]

**Tipp**  
AWS empfiehlt die Verwendung von[Aurora DSQL-Konnektoren für Node.js](SECTION_Node-js-connectors.md), die die Token-Generierung automatisch übernehmen.

Sie können das Token wie folgt erstellen:
+ Wenn Sie eine Verbindung mit der `admin` Rolle herstellen, verwenden Sie`getDbConnectAdminAuthToken`.
+ Wenn Sie eine Verbindung mit einer benutzerdefinierten Datenbankrolle herstellen, verwenden Sie`getDbConnectAuthToken`.

```
import { DsqlSigner } from "@aws-sdk/dsql-signer";

async function generateToken(yourClusterEndpoint, region) {
  const signer = new DsqlSigner({
    hostname: yourClusterEndpoint,
    region,
  });
  try {
    // Use `getDbConnectAuthToken` if you are _not_ logging in as the `admin` user
    const token = await signer.getDbConnectAdminAuthToken();
    console.log(token);
    return token;
  } catch (error) {
      console.error("Failed to generate token: ", error);
      throw error;
  }
}
```

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

**Tipp**  
AWS empfiehlt die Verwendung von[Aurora DSQL-Konnektor für Java JDBC](SECTION_program-with-jdbc-connector.md), die die Token-Generierung automatisch durchführt.

Sie können das Token wie folgt erstellen:
+ Wenn Sie eine Verbindung mit der `admin` Rolle herstellen, verwenden Sie`generateDbConnectAdminAuthToken`.
+ Wenn Sie eine Verbindung mit einer benutzerdefinierten Datenbankrolle herstellen, verwenden Sie`generateDbConnectAuthToken`.

```
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.services.dsql.DsqlUtilities;
import software.amazon.awssdk.regions.Region;

public class GenerateAuthToken { 
    public static String generateToken(String yourClusterEndpoint, Region region) {
        DsqlUtilities utilities = DsqlUtilities.builder()
                .region(region)
                .credentialsProvider(DefaultCredentialsProvider.builder().build())
                .build();

        // Use `generateDbConnectAuthToken` if you are _not_ logging in as `admin` user 
        String token = utilities.generateDbConnectAdminAuthToken(builder -> {
            builder.hostname(yourClusterEndpoint)
                    .region(region);
        });

        System.out.println(token);
        return token;
    }
}
```

------
#### [ Rust SDK ]

**Tipp**  
AWS empfiehlt die Verwendung von[Aurora DSQL-Konnektor für Rust SQLx](SECTION_program-with-dsql-connector-for-rust-sqlx.md), die die Token-Generierung automatisch durchführt.

Sie können das Token wie folgt erstellen:
+ Wenn Sie eine Verbindung mit der `admin` Rolle herstellen, verwenden Sie`db_connect_admin_auth_token`.
+ Wenn Sie eine Verbindung mit einer benutzerdefinierten Datenbankrolle herstellen, verwenden Sie`db_connect_auth_token`.

```
use aws_config::{BehaviorVersion, Region};
use aws_sdk_dsql::auth_token::{AuthTokenGenerator, Config};

async fn generate_token(your_cluster_endpoint: String, region: String) -> String {
    let sdk_config = aws_config::load_defaults(BehaviorVersion::latest()).await;
    let signer = AuthTokenGenerator::new(
        Config::builder()
            .hostname(&your_cluster_endpoint)
            .region(Region::new(region))
            .build()
            .unwrap(),
    );

    // Use `db_connect_auth_token` if you are _not_ logging in as `admin` user
    let token = signer.db_connect_admin_auth_token(&sdk_config).await.unwrap();
    println!("{}", token);
    token.to_string()
}
```

------
#### [ Ruby SDK ]

**Tipp**  
AWS empfiehlt die Verwendung von[Aurora DSQL-Konnektor für Ruby pg](SECTION_program-with-dsql-connector-for-ruby-pg.md), die die Token-Generierung automatisch durchführt.

Sie können das Token wie folgt erstellen:
+ Wenn Sie eine Verbindung mit der `admin` Rolle herstellen, verwenden Sie`generate_db_connect_admin_auth_token`.
+ Wenn Sie eine Verbindung mit einer benutzerdefinierten Datenbankrolle herstellen, verwenden Sie`generate_db_connect_auth_token`.

```
require 'aws-sdk-dsql'

def generate_token(your_cluster_endpoint, region)
  credentials = Aws::CredentialProviderChain.new.resolve

  token_generator = Aws::DSQL::AuthTokenGenerator.new({
    :credentials => credentials
  })

  # if you're not using admin role, use generate_db_connect_auth_token instead
  token = token_generator.generate_db_connect_admin_auth_token({
    :endpoint => your_cluster_endpoint,
    :region => region
  })
end
```

------
#### [ PHP SDK ]

**Tipp**  
AWS empfiehlt die Verwendung von[Aurora DSQL-Konnektor für PHP `PDO_PGSQL`](SECTION_program-with-dsql-connector-for-php-pdo-pgsql.md), die die Token-Generierung automatisch durchführt.

Sie können das Token wie folgt erstellen:
+ Wenn Sie eine Verbindung mit der `admin` Rolle herstellen, verwenden Sie`generateDbConnectAdminAuthToken`.
+ Wenn Sie eine Verbindung mit einer benutzerdefinierten Datenbankrolle herstellen, verwenden Sie`generateDbConnectAuthToken`.

```
<?php
require 'vendor/autoload.php';

use Aws\DSQL\AuthTokenGenerator;
use Aws\Credentials\CredentialProvider;

function generateToken(string $yourClusterEndpoint, string $region): string {
    $provider = CredentialProvider::defaultProvider();
    $generator = new AuthTokenGenerator($provider);

    // Use generateDbConnectAuthToken if you are not connecting as admin
    $token = $generator->generateDbConnectAdminAuthToken($yourClusterEndpoint, $region);

    echo $token . PHP_EOL;
    return $token;
}
```

------
#### [ .NET ]

**Tipp**  
AWS empfiehlt die Verwendung von[Aurora DSQL-Konnektor für.NET Npgsql](SECTION_program-with-dsql-connector-for-dotnet-npgsql.md), die die Token-Generierung automatisch durchführt.

**Anmerkung**  
Das offizielle SDK für .NET enthält keinen integrierten API-Aufruf zur Generierung eines Authentifizierungstokens für Aurora DSQL. Stattdessen müssen Sie die Utility-Klasse `DSQLAuthTokenGenerator` verwenden. Im folgenden Codebeispiel sehen Sie, wie das Authentifizierungstoken für .NET generiert wird. 

Sie können das Token wie folgt erstellen:
+ Wenn Sie eine Verbindung mit der `admin` Rolle herstellen, verwenden Sie`DbConnectAdmin`.
+ Wenn Sie eine Verbindung mit einer benutzerdefinierten Datenbankrolle herstellen, verwenden Sie`DbConnect`.

Im folgenden Beispiel wird die Utility-Klasse `DSQLAuthTokenGenerator` verwendet, um das Authentifizierungstoken für einen Benutzer mit der Rolle `admin` zu generieren. Ersetzen Sie es {{insert-dsql-cluster-endpoint}} durch Ihren Cluster-Endpunkt.

```
using Amazon;
using Amazon.DSQL.Util;

var yourClusterEndpoint = "{{insert-dsql-cluster-endpoint}}";

// Use `DSQLAuthTokenGenerator.GenerateDbConnectAuthToken` if you are _not_ logging in as `admin` user
var token = DSQLAuthTokenGenerator.GenerateDbConnectAdminAuthToken(RegionEndpoint.USEast1, yourClusterEndpoint);

Console.WriteLine(token);
```

------
#### [ Go ]

**Tipp**  
AWS empfiehlt die Verwendung von[Aurora DSQL-Konnektor für Go pgx](SECTION_program-with-go-pgx-connector.md), die die Token-Generierung automatisch durchführt.

Das AWS SDK for Go v2 bietet eine integrierte Methode zum Generieren von Authentifizierungstoken im [https://github.com/aws/aws-sdk-go-v2/tree/main/feature/dsql/auth](https://github.com/aws/aws-sdk-go-v2/tree/main/feature/dsql/auth)Paket.
+ Wenn Sie eine Verbindung mit der `admin` Rolle herstellen, verwenden Sie`auth.GenerateDBConnectAdminAuthToken`.
+ Wenn Sie eine Verbindung mit einer benutzerdefinierten Datenbankrolle herstellen, verwenden Sie`auth.GenerateDbConnectAuthToken`.

```
package main

import (
	"context"
	"fmt"

	"github.com/aws/aws-sdk-go-v2/config"
	"github.com/aws/aws-sdk-go-v2/feature/dsql/auth"
)

func main() {
	ctx := context.Background()

	cfg, err := config.LoadDefaultConfig(ctx, config.WithRegion("{{region}}"))
	if err != nil {
		panic(err)
	}

	// Use auth.GenerateDbConnectAuthToken for non-admin users
	token, err := auth.GenerateDBConnectAdminAuthToken(ctx, "{{yourClusterEndpoint}}", "{{region}}", cfg.Credentials)
	if err != nil {
		panic(err)
	}

	fmt.Println(token)
}
```

------