Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Menghasilkan token otentikasi di Amazon Aurora DSQL
<a name="SECTION_authentication-token"></a>

Untuk terhubung ke Amazon Aurora DSQL dengan klien SQL, buat token otentikasi untuk digunakan sebagai kata sandi. Token ini hanya digunakan untuk mengautentikasi koneksi. Setelah koneksi dibuat, koneksi tetap valid bahkan jika token otentikasi kedaluwarsa.

Jika Anda membuat token otentikasi menggunakan AWS konsol, token, atau AWS CLI SDKs, token secara otomatis kedaluwarsa dalam 15 menit secara default. Durasi maksimum adalah 604.800 detik, yaitu satu minggu. Untuk terhubung ke Aurora DSQL dari klien Anda lagi, Anda dapat menggunakan token otentikasi yang sama jika belum kedaluwarsa, atau Anda dapat membuat yang baru.

Untuk memulai membuat token, [buat kebijakan IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create-console.html) dan [cluster di Aurora](https://docs.aws.amazon.com/aurora-dsql/latest/userguide/getting-started.html#getting-started-quickstart) DSQL. Kemudian gunakan AWS konsol, AWS CLI, atau AWS SDKs untuk menghasilkan token.

Minimal, Anda harus memiliki izin IAM yang tercantum[Menghubungkan ke klaster Anda menggunakan IAM](authentication-authorization.md#authentication-authorization-iam-role-connect), tergantung pada peran database yang Anda gunakan untuk terhubung.

**Topics**
+ [Gunakan AWS konsol untuk menghasilkan token otentikasi di Aurora DSQL](#authentication-token-console)
+ [Gunakan AWS CloudShell untuk menghasilkan token otentikasi di Aurora DSQL](#authentication-token-cloudshell)
+ [Gunakan AWS CLI untuk menghasilkan token otentikasi di Aurora DSQL](#authentication-token-cli)
+ [Gunakan SDKs untuk menghasilkan token di Aurora DSQL](#authentication-token-sdks)

## Gunakan AWS konsol untuk menghasilkan token otentikasi di Aurora DSQL
<a name="authentication-token-console"></a>

Aurora DSQL mengautentikasi pengguna dengan token daripada kata sandi. Anda dapat menghasilkan token dari konsol.

**Untuk menghasilkan token otentikasi**

1. Masuk ke Konsol Manajemen AWS dan buka konsol Aurora DSQL di. [https://console.aws.amazon.com/dsql](https://console.aws.amazon.com/dsql)

1. Pilih ID cluster cluster yang ingin Anda buat token otentikasi. Jika Anda belum membuat cluster, ikuti langkah-langkah di [Langkah 1: Buat cluster Aurora DSQL Single-region](getting-started.md#getting-started-create-cluster) atau[Langkah 4 (Opsional): Buat cluster Multi-region](getting-started.md#getting-started-multi-region).

1. Pilih **Connect** dan kemudian pilih **Get Token**.

1. Pilih apakah Anda ingin terhubung sebagai `admin` atau dengan [peran basis data kustom](https://docs.aws.amazon.com/aurora-dsql/latest/userguide/authentication-authorization.html#authentication-authorization-iam-role-connect).

1. Salin token otentikasi yang dihasilkan dan gunakan untuk[Akses Aurora DSQL menggunakan klien SQL](accessing.md#accessing-sql-clients).

Untuk mempelajari lebih lanjut tentang peran basis data kustom dan IAM di Aurora DSQL, lihat. [Otentikasi dan otorisasi untuk Aurora DSQL](authentication-authorization.md)

## Gunakan AWS CloudShell untuk menghasilkan token otentikasi di Aurora DSQL
<a name="authentication-token-cloudshell"></a>

Sebelum Anda dapat membuat token otentikasi menggunakan AWS CloudShell, pastikan bahwa Anda [membuat cluster Aurora DSQL](https://docs.aws.amazon.com/aurora-dsql/latest/userguide/getting-started.html#getting-started-quickstart).

**Untuk menghasilkan token otentikasi menggunakan AWS CloudShell**

1. Masuk ke Konsol Manajemen AWS dan buka konsol Aurora DSQL di. [https://console.aws.amazon.com/dsql](https://console.aws.amazon.com/dsql)

1. Di kiri bawah AWS konsol, pilih AWS CloudShell.

1. Jalankan perintah berikut untuk menghasilkan token otentikasi untuk `admin` peran tersebut. Ganti *us-east-1* dengan Wilayah Anda dan *your\$1cluster\$1endpoint* dengan titik akhir cluster Anda sendiri. 
**catatan**  
Jika Anda tidak terhubung sebagai`admin`, gunakan sebagai `generate-db-connect-auth-token` gantinya.

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

   Jika Anda mengalami masalah, lihat [Memecahkan Masalah IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/troubleshoot.html) dan [Bagaimana cara memecahkan masalah akses ditolak atau kesalahan operasi yang tidak sah](https://repost.aws/knowledge-center/troubleshoot-iam-policy-issues) dengan kebijakan IAM? .

1. Gunakan perintah berikut untuk digunakan `psql` untuk memulai koneksi ke cluster Anda.

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

1. Anda akan melihat prompt untuk memberikan kata sandi. Salin token yang Anda buat, dan pastikan Anda tidak menyertakan spasi atau karakter tambahan. Tempelkan ke prompt berikut dari`psql`.

   ```
   Password for user admin: 
   ```

1. Tekan **Enter**. Anda akan melihat prompt PostgreSQL.

   ```
   postgres=>
   ```

   Jika Anda mendapatkan kesalahan akses ditolak, pastikan identitas IAM Anda memiliki `dsql:DbConnectAdmin` izin. Jika Anda memiliki izin dan terus mendapatkan kesalahan penolakan akses, lihat [Memecahkan masalah IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/troubleshoot.html) dan [Bagaimana saya bisa memecahkan masalah kesalahan operasi yang ditolak atau tidak sah](https://repost.aws/knowledge-center/troubleshoot-iam-policy-issues) dengan kebijakan IAM? . 

Untuk mempelajari lebih lanjut tentang peran basis data kustom dan IAM di Aurora DSQL, lihat. [Otentikasi dan otorisasi untuk Aurora DSQL](authentication-authorization.md)

## Gunakan AWS CLI untuk menghasilkan token otentikasi di Aurora DSQL
<a name="authentication-token-cli"></a>

Ketika cluster Anda`ACTIVE`, Anda dapat menghasilkan token otentikasi pada CLI dengan menggunakan `aws dsql` perintah. Gunakan salah satu dari teknik berikut:

**catatan**  
Pembuatan Token adalah operasi lokal yang menandatangani permintaan menggunakan kredenal IAM Anda saat ini. Itu tidak menghubungi AWS untuk memvalidasi kredensil. Jika kredensil Anda kedaluwarsa atau tidak valid, pembuatan token masih berhasil, tetapi upaya koneksi gagal. Pastikan kredensi IAM Anda valid sebelum membuat token.
+ Jika Anda terhubung dengan `admin` peran tersebut, gunakan `generate-db-connect-admin-auth-token` opsi.
+ Jika Anda terhubung dengan peran basis data kustom, gunakan `generate-db-connect-auth-token` opsi.

Contoh berikut menggunakan atribut berikut untuk menghasilkan token otentikasi untuk `admin` peran tersebut.
+ *your\$1cluster\$1endpoint*— Titik akhir cluster. Ini mengikuti format`your_cluster_identifier.dsql.region.on.aws`, seperti pada contoh`01abc2ldefg3hijklmnopqurstu.dsql.us-east-1.on.aws`.
+ *region*— The Wilayah AWS, seperti `us-east-2` atau`us-east-1`.

Contoh berikut mengatur waktu kedaluwarsa token untuk kedaluwarsa dalam 3600 detik (1 jam).

------
#### [ 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
```

------

## Gunakan SDKs untuk menghasilkan token di Aurora DSQL
<a name="authentication-token-sdks"></a>

Anda dapat membuat token otentikasi untuk klaster Anda saat berada dalam `ACTIVE` status. Contoh SDK menggunakan atribut berikut untuk menghasilkan token otentikasi untuk peran tersebut`admin`:
+ *your\$1cluster\$1endpoint*(atau*yourClusterEndpoint*) — Titik akhir cluster Aurora DSQL Anda. Format penamaan adalah`your_cluster_identifier.dsql.region.on.aws`, seperti pada contoh`01abc2ldefg3hijklmnopqurstu.dsql.us-east-1.on.aws`.
+ *region*(atau*RegionEndpoint*) — Wilayah AWS Di mana cluster Anda berada, seperti `us-east-2` atau`us-east-1`.

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

**Tip**  
AWS merekomendasikan penggunaan[Konektor Aurora DSQL untuk PythonTentang KonektorApa itu Autentikasi Aurora DSQL?FiturPanduan memulai cepatPersyaratanPenginstalanInstal psycopg atau psycopg2 atau asyncpg secara terpisahPenggunaan Dasarpsycopgpsycopg2asyncpgHanya menggunakan hostpsycopgpsycopg2asyncpgHanya menggunakan ID clusterpsycopgpsycopg2asyncpgpsycopgpsycopg2asyncpgString Koneksipsycopgpsycopg2asyncpgKonfigurasi Lanjutanpsycopgpsycopg2asyncpgOpsi konfigurasiMenggunakan konektor Aurora DSQL untuk Python dengan penyatuan koneksipsycopgpsycopg2asyncpgAutentikasiAdmin vs Pengguna RegulerContohpsycopgpsycopg2asyncpg](SECTION_program-with-dsql-connector-for-python.md), yang menangani pembuatan token secara otomatis.

Anda dapat membuat token dengan cara berikut:
+ Jika Anda terhubung dengan `admin` peran, gunakan`generate_db_connect_admin_auth_token`.
+ Jika Anda terhubung dengan peran basis data kustom, gunakan`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\$1\$1 SDK ]

Anda dapat membuat token dengan cara berikut:
+ Jika Anda terhubung dengan `admin` peran, gunakan`GenerateDBConnectAdminAuthToken`.
+ Jika Anda terhubung dengan peran basis data kustom, gunakan`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 ]

**Tip**  
AWS merekomendasikan penggunaan[Konektor Aurora DSQL untuk Node.js](SECTION_Node-js-connectors.md), yang menangani pembuatan token secara otomatis.

Anda dapat membuat token dengan cara berikut:
+ Jika Anda terhubung dengan `admin` peran, gunakan`getDbConnectAdminAuthToken`.
+ Jika Anda terhubung dengan peran basis data kustom, gunakan`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 ]

**Tip**  
AWS merekomendasikan penggunaan[Konektor Aurora DSQL untuk Java JDBC](SECTION_program-with-jdbc-connector.md), yang menangani pembuatan token secara otomatis.

Anda dapat membuat token dengan cara berikut:
+ Jika Anda terhubung dengan `admin` peran, gunakan`generateDbConnectAdminAuthToken`.
+ Jika Anda terhubung dengan peran basis data kustom, gunakan`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 ]

**Tip**  
AWS merekomendasikan penggunaan[Konektor Aurora DSQL untuk Karat SQLx](SECTION_program-with-dsql-connector-for-rust-sqlx.md), yang menangani pembuatan token secara otomatis.

Anda dapat membuat token dengan cara berikut:
+ Jika Anda terhubung dengan `admin` peran, gunakan`db_connect_admin_auth_token`.
+ Jika Anda terhubung dengan peran basis data kustom, gunakan`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 ]

**Tip**  
AWS merekomendasikan penggunaan[Konektor Aurora DSQL untuk Ruby pg](SECTION_program-with-dsql-connector-for-ruby-pg.md), yang menangani pembuatan token secara otomatis.

Anda dapat membuat token dengan cara berikut:
+ Jika Anda terhubung dengan `admin` peran, gunakan`generate_db_connect_admin_auth_token`.
+ Jika Anda terhubung dengan peran basis data kustom, gunakan`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 ]

**Tip**  
AWS merekomendasikan penggunaan[Konektor Aurora DSQL untuk PHP `PDO_PGSQL`](SECTION_program-with-dsql-connector-for-php-pdo-pgsql.md), yang menangani pembuatan token secara otomatis.

Anda dapat membuat token dengan cara berikut:
+ Jika Anda terhubung dengan `admin` peran, gunakan`generateDbConnectAdminAuthToken`.
+ Jika Anda terhubung dengan peran basis data kustom, gunakan`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 ]

**Tip**  
AWS merekomendasikan penggunaan[Konektor Aurora DSQL untuk .NET Npgsql](SECTION_program-with-dsql-connector-for-dotnet-npgsql.md), yang menangani pembuatan token secara otomatis.

**catatan**  
SDK resmi untuk .NET tidak menyertakan panggilan API bawaan untuk menghasilkan token otentikasi untuk Aurora DSQL. Sebaliknya, Anda harus menggunakan`DSQLAuthTokenGenerator`, yang merupakan kelas utilitas. Contoh kode berikut menunjukkan cara menghasilkan token otentikasi untuk.NET. 

Anda dapat membuat token dengan cara berikut:
+ Jika Anda terhubung dengan `admin` peran, gunakan`DbConnectAdmin`.
+ Jika Anda terhubung dengan peran basis data kustom, gunakan`DbConnect`.

Contoh berikut menggunakan kelas `DSQLAuthTokenGenerator` utilitas untuk menghasilkan token otentikasi untuk pengguna dengan `admin` peran. Ganti *insert-dsql-cluster-endpoint* dengan titik akhir cluster Anda.

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

**Tip**  
AWS merekomendasikan penggunaan[Konektor Aurora DSQL untuk Go pgx](SECTION_program-with-go-pgx-connector.md), yang menangani pembuatan token secara otomatis.

 AWS SDK for Go v2 menyediakan metode bawaan untuk menghasilkan token otentikasi dalam [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.
+ Jika Anda terhubung dengan `admin` peran, gunakan`auth.GenerateDBConnectAdminAuthToken`.
+ Jika Anda terhubung dengan peran basis data kustom, gunakan`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)
}
```

------