# MariaDB、MySQL、および PostgreSQL の IAM データベース認証
<a name="UsingWithRDS.IAMDBAuth"></a>

AWS Identity and Access Management (IAM) データベース認証を使用して、DB インスタンスを認証できます。IAM データベース認証には、MariaDB、MySQL、および PostgreSQL を使用します。この認証方法では、DB インスタンスに接続するときにパスワードを使用する必要はありません。代わりに、認証トークンを使用します。

*認証トークン*は、Amazon RDS がリクエストに応じて生成する一意の文字列です。認証トークンは、AWS 署名バージョン 4 を使用して生成されます。各トークンには 15 分の有効期間があります。認証は IAM を使用して外部的に管理されるため、ユーザー認証情報をデータベースに保存する必要はありません。引き続きスタンダードのデータベース認証を使用することもできます。トークンは認証にのみ使用され、確立後のセッションには影響しません。

IAM データベース認証には次の利点があります。
+ データベースとの間で送受信されるネットワークトラフィックは、Secure Socket Layer (SSL) または Transport Layer Security (TLS) を使用して暗号化されます。Amazon RDS で SSL/TLS を使用する方法については、「[SSL/TLS を使用した DB インスタンスまたはクラスターへの接続の暗号化](UsingWithRDS.SSL.md)」を参照してください。
+ IAM を使用して各 DB インスタンスで個別に管理するのではなく、データベースリソースへのアクセスを一元的に管理できます。
+ Amazon EC2 で実行するアプリケーションの場合、セキュリティを高めるため、EC2 インスタンスに固有のプロファイル認証情報を使用して、パスワードの代わりにデータベースにアクセスできます。

一般に、アプリケーションが 1 秒あたり 200 未満の接続を作成し、アプリケーションコードでユーザー名とパスワードを直接管理したくない場合は、IAM データベース認証の使用を検討してください。

Amazon Web Services (AWS) JDBC ドライバーは IAM データベース認証をサポートしています。詳細については、「Amazon Web Services (AWS) JDBC ドライバー GitHub リポジトリ」の「[AWS IAM Authentication Plugin](https://github.com/aws/aws-advanced-jdbc-wrapper/blob/main/docs/using-the-jdbc-driver/using-plugins/UsingTheIamAuthenticationPlugin.md)」を参照してください。[https://github.com/aws/aws-advanced-jdbc-wrapper](https://github.com/aws/aws-advanced-jdbc-wrapper)

Amazon Web Services (AWS) Python ドライバーは IAM データベース認証をサポートしています。詳細については、「Amazon Web Services (AWS) Python ドライバー GitHub リポジトリ」の「[AWS IAM Authentication Plugin](https://github.com/aws/aws-advanced-python-wrapper/blob/main/docs/using-the-python-driver/using-plugins/UsingTheIamAuthenticationPlugin.md)」を参照してください。[https://github.com/aws/aws-advanced-python-wrapper](https://github.com/aws/aws-advanced-python-wrapper)

DB 認証に IAM を設定するプロセスについては、以下のトピックを参照してください。
+ [IAM データベース認証の有効化と無効化](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [IAM データベースアクセス用の IAM ポリシーの作成と使用](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [IAM 認証を使用したデータベースアカウントの作成](UsingWithRDS.IAMDBAuth.DBAccounts.md)
+ [IAM 認証を使用した DB インスタンスへの接続](UsingWithRDS.IAMDBAuth.Connecting.md) 

## 利用可能なリージョンとバージョン
<a name="UsingWithRDS.IAMDBAuth.Availability"></a>

機能の可用性とサポートは、各データベースエンジンの特定のバージョンによって異なります。Amazon RDS と IAM データベース認証を使用したエンジン、バージョン、リージョンの可用性の詳細については、「[Amazon RDS での IAM データベース認証でサポートされているリージョンと DB エンジン](Concepts.RDS_Fea_Regions_DB-eng.Feature.IamDatabaseAuthentication.md)」を参照してください。

## CLI および SDK のサポート
<a name="UsingWithRDS.IAMDBAuth.cli-sdk"></a>

IAM データベース認証は、[AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/rds/generate-db-auth-token.html) と以下の各言語固有の AWS SDK について使用できます。
+ [AWS SDK for .NET](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/RDS/TRDSAuthTokenGenerator.html)
+ [AWS SDK for C\$1\$1](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/class_aws_1_1_r_d_s_1_1_r_d_s_client.html#ae134ffffed5d7672f6156d324e7bd392)
+ [AWS SDK for Go](https://docs.aws.amazon.com/sdk-for-go/api/service/rds/#pkg-overview)
+ [AWS SDK for Java](https://docs.aws.amazon.com/sdk-for-java/latest/reference/software/amazon/awssdk/services/rds/RdsUtilities.html)
+ [AWS SDK for JavaScript](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/modules/_aws_sdk_rds_signer.html)
+ [AWS SDK for PHP](https://docs.aws.amazon.com/aws-sdk-php/v3/api/class-Aws.Rds.AuthTokenGenerator.html)
+ [AWS SDK for Python (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/rds.html#RDS.Client.generate_db_auth_token)
+ [AWS SDK for Ruby](https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/RDS/AuthTokenGenerator.html)

## IAM データベース認証の制限
<a name="UsingWithRDS.IAMDBAuth.Limitations"></a>

IAM データベース認証を使用する場合、以下の制限が適用されます。
+ 現在、IAM データベース認証はすべてのグローバル条件コンテキストキーをサポートしていません。

  グローバル条件コンテキストキーの詳細については、「*IAM ユーザーガイド*」の「[AWS グローバル条件コンテキストキー](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html)」を参照してください。
+ PostgreSQL の場合、IAM ロール (`rds_iam`) がマスターユーザーに追加される (マスターユーザーである RDS を含む) と、IAM 認証はパスワード認証よりも優先されるため、ユーザーは IAM ユーザーとしてログインする必要があります。
+ PostgreSQL の場合、Amazon RDS は IAM 認証方法と Kerberos 認証方法両方の同時有効化をサポートしていません。
+ PostgreSQL では、IAM 認証を使用してレプリケーション接続を確立することはできません。
+ DB インスタンス エンドポイントの代わりに、カスタム Route 53 DNS レコードを使用して認証トークンを生成することはできません。
+ CloudWatch と CloudTrail は IAM 認証のログ記録を行いません。これらのサービスは、IAM ロールにデータベース接続の有効化を許可する `generate-db-auth-token` API コールを追跡しません。
+ IAM DB 認証には、データベースインスタンスのコンピューティングリソースが必要です。信頼性の高い接続を実現するには、データベースに 300～1,000 MiB 以上の追加メモリが必要です。ワークロードに必要なメモリを確認するには、IAM DB 認証を有効にする前と後に、拡張モニタリングプロセスリストの RDS プロセスの RES 列を比較します。「[RDS コンソールでの OS メトリクスの表示](USER_Monitoring.OS.Viewing.md)」を参照してください。

  バースト可能なクラスインスタンスを使用している場合は、バッファやキャッシュなどの他のパラメータで使用されるメモリを同じ量だけ減らして、メモリが不足しないようにします。
+ IAM DB 認証は、どのエンジンの RDS on Outposts でもサポートされていません。

## IAM データベース認証に関する推奨事項
<a name="UsingWithRDS.IAMDBAuth.ConnectionsPerSecond"></a>

IAM データベース認証を使用する場合には、以下のことをお勧めします。
+ アプリケーションが必要とする新しい IAM データベース認証接続が 1 秒あたり 200 未満の場合は、IAM データベース認証を使用します。

  Amazon RDS を使用するデータベースエンジンでは、1 秒あたりの認証試行回数に制限はありません。ただし、IAM データベース認証を使用するときは、アプリケーションは認証トークンを生成する必要があります。次に、アプリケーションはそのトークンを使用して DB インスタンスに接続します。1 秒あたりの新しい接続数の上限を超えた場合、IAM データベース認証の追加オーバーヘッドによって接続のスロットリングが発生する場合があります。

  接続が頻繁に作成されるのを軽減するために、アプリケーションで接続プールを使用することを検討してください。これにより、IAM DB 認証のオーバーヘッドが軽減され、アプリケーションで既存の接続を再利用できるようになります。または、これらのユースケースでは RDS Proxy の使用を検討してください。RDS Proxy には追加料金がかかります。「[RDS Proxy の料金表](https://aws.amazon.com/rds/proxy/pricing/)」をご覧ください。
+ IAM データベース認証トークンのサイズは、IAM タグの数、IAM サービスポリシー、ARN の長さ、その他の IAM やデータベースのプロパティなど、さまざまな要素によって異なります。このトークンの最小サイズは、通常、約 1 KB ですが、それ以上になることもあります。このトークンは IAM 認証を使用するデータベースへの接続文字列のパスワードとして使用されるため、データベースドライバー (ODBC など) やツールが、サイズを理由にこのトークンを制限したり、切り詰めたりしないようにする必要があります。トークンが切り詰められると、データベースと IAM による認証検証は失敗します。
+ IAM データベース認証トークンの作成時に一時的な認証情報を使用している場合でも、IAM データベース認証トークンを使用して接続リクエストを行うときには、その一時的な認証情報が引き続き有効なものである必要があります。

## サポートされていない AWS グローバル条件コンテキストキー
<a name="UsingWithRDS.IAMDBAuth.GlobalContextKeys"></a>

 IAMデータベース認証は AWS グローバル条件コンテキストキーのうち次のサブセットをサポートしていません。
+ `aws:Referer`
+ `aws:SourceIp`
+ `aws:SourceVpc`
+ `aws:SourceVpce`
+ `aws:UserAgent`
+ `aws:VpcSourceIp`

条件キーの詳細については、[IAM ユーザーガイド](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) の「*AWS グローバル条件コンテキストキー」* を参照してください。

# IAM データベース認証の有効化と無効化
<a name="UsingWithRDS.IAMDBAuth.Enabling"></a>

デフォルトでは、IAM データベース認証は DB インスタンスで無効になります。AWS マネジメントコンソール、AWS CLI、API のいずれかを使用して、IAM データベース認証を有効または無効にすることができます。

次のいずれかのアクションを実行する際に、IAM データベース認証を有効にすることができます。
+ IAM データベース認証を有効にして新しい DB インスタンスを作成するには、「[Amazon RDS DB インスタンスの作成](USER_CreateDBInstance.md)」を参照してください。
+ DB インスタンスを変更して IAM データベース認証を有効にするには、「[Amazon RDS DB インスタンスを変更する](Overview.DBInstance.Modifying.md)」を参照してください。
+ IAM データベース認証を有効にしてスナップショットから DB インスタンスを復元するには、「[DB インスタンスへの復元](USER_RestoreFromSnapshot.md)」を参照してください。
+ IAM データベース認証を有効化しながら DB インスタンスを特定の時点に復元するには、「[Amazon RDS の DB インスタンスを特定の時点に復元する](USER_PIT.md)」を参照してください。

## コンソール
<a name="UsingWithRDS.IAMDBAuth.Enabling.Console"></a>

作成または変更の各ワークフローには、[**データベース認証**] セクションがあり、IAM データベース認証を有効または無効にすることができます。そのセクションで、[**パスワードと IAM データベース認証**] を選択して、IAM データベース認証を有効にします。

**既存の DB インスタンスに対して IAM データベース認証を有効または無効にするには**

1. Amazon RDS コンソール ([https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/)) を開きます。

1. ナビゲーションペインで、[**データベース**] を選択します。

1. 変更する DB インスタンスを選択します。
**注記**  
 DB インスタンスが IAM 認証と互換性があることを確認します。[利用可能なリージョンとバージョン](UsingWithRDS.IAMDBAuth.md#UsingWithRDS.IAMDBAuth.Availability) の互換性要件を確認する。

1. [**Modify**] を選択します。

1. **[データベース認証]** セクションで、**[パスワードと IAM データベース認証]** を選択して、 を有効にします。IAM 認証を無効にするには、**[パスワード認証]** または **[パスワードと Kerberos 認証]** を選択します。

1. CloudWatch Logs への IAM DB 認証ログの発行を有効にすることもできます。**[ログのエクスポート]** で、**[iam-db-auth-error ログ]** オプションを選択します。ログを CloudWatch Logs に発行するとストレージが消費され、その分の料金が発生します。不要になった CloudWatch Logs は削除してください。

1. [**Continue**] を選択します。

1. 変更をすぐに適用するには、[**変更のスケジューリング**] セクションで [**今すぐ**] を選択します。

1. [**DB インスタンスを変更** ] を選択します。

## AWS CLI
<a name="UsingWithRDS.IAMDBAuth.Enabling.CLI"></a>

AWS CLI を使用して、IAM 認証で新しい DB インスタンスを作成するには、[https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-instance.html](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-instance.html) コマンドを使用します。次の例のように、`--enable-iam-database-authentication` オプションを指定します。

```
aws rds create-db-instance \
    --db-instance-identifier mydbinstance \
    --db-instance-class db.m3.medium \
    --engine MySQL \
    --allocated-storage 20 \
    --master-username masterawsuser \
    --manage-master-user-password \
    --enable-iam-database-authentication
```

既存の DB インスタンスを更新して、IAM 認証を使用するかどうかを指定するには、AWS CLI コマンド [https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html) を使用します。必要に応じて `--enable-iam-database-authentication` または `--no-enable-iam-database-authentication` オプションを指定します。

**注記**  
 DB インスタンスが IAM 認証と互換性があることを確認します。[利用可能なリージョンとバージョン](UsingWithRDS.IAMDBAuth.md#UsingWithRDS.IAMDBAuth.Availability) の互換性要件を確認する。

デフォルトでは、Amazon RDS は次のメンテナンスウィンドウ中に変更を実行します。これを上書きし、IAM DB 認証をできるだけ早く有効にする場合は、`--apply-immediately` パラメータを使用します。

次の例は、既存の DB インスタンスの IAM 認証をすぐに有効にする方法を示しています。

```
aws rds modify-db-instance \
    --db-instance-identifier mydbinstance \
    --apply-immediately \
    --enable-iam-database-authentication
```

DB インスタンスを復元する場合は、次のいずれかの AWS CLI コマンドを使用します。
+ `[restore-db-instance-to-point-in-time](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-to-point-in-time.html)`
+ `[restore-db-instance-from-db-snapshot](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-from-db-snapshot.html)`

IAM データベース認証設定は、デフォルトで元のスナップショットの設定になります。この設定を変更するには、必要に応じて `--enable-iam-database-authentication` または `--no-enable-iam-database-authentication` オプションを設定します。

## RDS API
<a name="UsingWithRDS.IAMDBAuth.Enabling.API"></a>

API を使用して、IAM 認証で新しい DB インスタンスを作成するには、API オペレーション [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstance.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstance.html) を使用します。`EnableIAMDatabaseAuthentication` パラメータを `true` に設定します。

既存の DB インスタンスを更新して、IAM 認証を持つ、または持たないようにするには、API オペレーション [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html) を使用します。`EnableIAMDatabaseAuthentication` パラメータを `true` に設定して IAM 認証を有効にするか、`false` に設定して無効にします。

**注記**  
 DB インスタンスが IAM 認証と互換性があることを確認します。[利用可能なリージョンとバージョン](UsingWithRDS.IAMDBAuth.md#UsingWithRDS.IAMDBAuth.Availability) の互換性要件を確認する。

DB インスタンスを復元する場合は、次のいずれかの API オペレーションを使用します。
+ [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceFromDBSnapshot.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceFromDBSnapshot.html)
+  [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceToPointInTime.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceToPointInTime.html)

IAM データベース認証設定は、デフォルトで元のスナップショットの設定になります。この設定を変更するには、`EnableIAMDatabaseAuthentication` パラメータを `true` に設定して IAM 認証を有効にするか、`false` に設定して無効にします。

# IAM データベースアクセス用の IAM ポリシーの作成と使用
<a name="UsingWithRDS.IAMDBAuth.IAMPolicy"></a>

ユーザーまたはロールに DB インスタンスへの接続を許可するには、IAM ポリシーを作成する必要があります。その後、ポリシーをアクセス許可セットまたはロールにアタッチします。

**注記**  
IAM キーポリシーの詳細については、「[Amazon RDS での Identity and Access Management](UsingWithRDS.IAM.md)」を参照してください。

次のポリシー例では、ユーザーは IAM データベース認証を使用して、DB インスタンス​に接続できます。

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "rds-db:connect"
            ],
            "Resource": [
                "arn:aws:rds-db:us-east-2:111122223333:dbuser:db-ABCDEFGHIJKL01234/db_user"
            ]
        }
    ]
}
```

------

**重要**  
管理者権限を持つユーザーは、IAM ポリシーで明示的なアクセス許可が設定されていない場合でも、DB インスタンスのにアクセスできます。管理者アクセスを DB インスタンスのに制限するには、最低限のアクセス許可が適切に設定された IAM ロールを作成し、それを管理者に設定します。

**注記**  
`rds-db:` プレフィックスと、`rds:` で始まる他の RDS API オペレーションのプレフィックスを混同しないでください。IAM データベース認証に対してのみ、`rds-db:` プレフィックスと `rds-db:connect` アクションを使用します。これらは、その他のコンテキストでは有効ではありません。

このポリシーには、次の要素を持つ 1 つのステートメントが含まれています。
+ `Effect` - DB インスタンスへのアクセスを許可するには、`Allow` を指定します。アクセスを明示的に許可しない場合、デフォルトでアクセスは拒否されます。
+ `Action` - DB インスタンスへの接続を許可するには、`rds-db:connect` を指定します。
+ `Resource` - 1 つの DB インスタンスで 1 つのデータベースアカウントを示す Amazon リソースネーム (ARN) を指定します。ARN 形式は次のとおりです。

  ```
  arn:aws:rds-db:region:account-id:dbuser:DbiResourceId/db-user-name
  ```

  この形式では、以下のように置き換えます。
  + `region` は、DB インスタンスの AWS リージョンです。このポリシー例での AWS リージョンは `us-east-2` です。
  + `account-id` は DB インスタンスの AWS アカウント番号です。このポリシー例でのアカウント番号は `1234567890` です。ユーザーは DB インスタンスのアカウントと同じアカウントでなければなりません。

    クロスアカウントアクセスを実行するには、DB インスタンスのアカウントに上記のポリシーで IAM ロールを作成し、他のアカウントがそのロールを引き継ぐことを許可します。
  + `DbiResourceId` は、DB インスタンスの識別子です。この識別子は AWS リージョンに固有であり、変更されることはありません。このポリシー例での識別子は `db-ABCDEFGHIJKL01234` です。

    Amazon RDS 用の DB インスタンスのリソース ID を AWS マネジメントコンソール で検索するには、DB インスタンスを選択して、その詳細を表示します。そして、[**Configuration (設定)**] タブを選択します。[**設定**] セクションに [**リソース ID**] が表示されます。

    または、次のように AWS CLI コマンドを使用して、以下に示されているように、現在の AWS リージョンのすべての DB インスタンスの識別子とリソース ID をリストできます。

    ```
    aws rds describe-db-instances --query "DBInstances[*].[DBInstanceIdentifier,DbiResourceId]"
    ```

    Amazon Aurora を使用している場合は、`DbiResourceId` の代わりに `DbClusterResourceId` を指定してください。詳細については、*Amazon Aurora ユーザーガイド*の「[IAM データベースアクセス用の IAM ポリシーの作成と使用](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/UsingWithRDS.IAMDBAuth.IAMPolicy.html)」を参照してください。
**注記**  
RDS Proxy 経由でデータベースに接続する場合は、`prx-ABCDEFGHIJKL01234` などのプロキシリソース ID を指定します。RDS Proxy で IAM データベース認証を使用する方法については、「[IAM 認証を使用したデータベースへの接続](rds-proxy-connecting.md#rds-proxy-connecting-iam)」を参照してください。
  + `db-user-name` は、IAM 認証に関連付けるデータベースアカウントの名前です。このポリシー例で、データベースアカウントは `db_user` です。

多様なアクセスパターンをサポートするため、他の ARN を構築できます。次のポリシーでは、DB インスタンスで 2 つの異なるデータベースアカウントにアクセスできます。

------
#### [ JSON ]

****  

```
{
   "Version":"2012-10-17",		 	 	 
   "Statement": [
      {
         "Effect": "Allow",
         "Action": [
             "rds-db:connect"
         ],
         "Resource": [
             "arn:aws:rds-db:us-east-2:123456789012:dbuser:db-ABCDEFGHIJKL01234/jane_doe",
             "arn:aws:rds-db:us-east-2:123456789012:dbuser:db-ABCDEFGHIJKL01234/mary_roe"
         ]
      }
   ]
}
```

------

次のポリシーでは、特定の AWS アカウントと AWS リージョンのすべての DB インスタンスとデータベースアカウントに一致させるために「\$1」文字を使用します。

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "rds-db:connect"
            ],
            "Resource": [
                "arn:aws:rds-db:us-east-2:111122223333:dbuser:*/*"
            ]
        }
    ]
}
```

------

次のポリシーは、特定の AWS アカウントと AWS リージョンの DB インスタンスすべてに一致します。ただし、`jane_doe` データベースアカウントを持つ DB インスタンス または DB クラスターにのみにアクセスが許可されます。

------
#### [ JSON ]

****  

```
{
   "Version":"2012-10-17",		 	 	 
   "Statement": [
      {
         "Effect": "Allow",
         "Action": [
             "rds-db:connect"
         ],
         "Resource": [
             "arn:aws:rds-db:us-east-2:123456789012:dbuser:*/jane_doe"
         ]
      }
   ]
}
```

------

ユーザーまたはロールは、データベースユーザーがアクセスするデータベースにのみアクセスできます。例えば、DB インスタンスに *dev* という名前のデータベースと、*test* という名前の別のデータベースがあるとします。データベースユーザー `jane_doe` が *dev* のみにアクセスできる場合、`jane_doe` ユーザーでその DB インスタンスにアクセスできるユーザーまたはロールも、*dev* にのみアクセスできます。このアクセス制限は、テーブル、ビューなどその他のデータベースオブジェクトにも当てはまります。

管理者は、エンティティに必要な、指定されたリソースに対して特定の API オペレーションを実行するアクセス許可を付与する IAM ポリシーを作成する必要があります。続いて、管理者は、それらのアクセス許可を必要とするアクセス許可セットまたはロールに、そのポリシーをアタッチします。ポリシーの例については、「[Amazon RDS のアイデンティティベースのポリシーの例](security_iam_id-based-policy-examples.md)」を参照してください。

## IAM ポリシーをアクセス許可セットまたはロールにアタッチする
<a name="UsingWithRDS.IAMDBAuth.IAMPolicy.Attaching"></a>

データベース認証を許可する IAM ポリシーを作成した後、そのポリシーをアクセス許可セットまたはロールにアタッチする必要があります。このトピックに関するチュートリアルについては、*IAM ユーザーガイド*の「[はじめてのカスタマー管理ポリシーの作成とアタッチ](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_managed-policies.html)」を参照してください。

チュートリアルを進める際に、このセクションに記載されているいずれかのポリシー例をスタート点として使用し、ニーズに合わせて調整することができます。チュートリアルを完了すると、`rds-db:connect` アクションを利用できる、ポリシーがアタッチされたアクセス許可セットが作成されます。

**注記**  
複数のアクセス許可セットまたはロールを同じデータベースユーザーアカウントにマップできます。例えば、IAM ポリシーで以下のリソース ARN を指定したとします。  

```
arn:aws:rds-db:us-east-2:123456789012:dbuser:db-12ABC34DEFG5HIJ6KLMNOP78QR/jane_doe
```
ポリシーを *Jane*、*Bob*、*Diego* にアタッチした場合、これらの各ユーザーは、`jane_doe` データベースアカウントを使用して、指定された DB インスタンスに接続できます。

# IAM 認証を使用したデータベースアカウントの作成
<a name="UsingWithRDS.IAMDBAuth.DBAccounts"></a>

IAM データベース認証では、作成するユーザーアカウントにデータベースのパスワードを割り当てる必要はありません。データベースアカウントにマッピングされているユーザーを削除した場合は、`DROP USER` ステートメントでデータベースアカウントも削除する必要があります。

**注記**  
IAM 認証に使用されるユーザー名は、データベース内のユーザー名の大文字および小文字と一致する必要があります。

**Topics**
+ [

## MariaDB および MySQL での IAM 認証の使用
](#UsingWithRDS.IAMDBAuth.DBAccounts.MySQL)
+ [

## PostgreSQL での IAM 認証の使用
](#UsingWithRDS.IAMDBAuth.DBAccounts.PostgreSQL)

## MariaDB および MySQL での IAM 認証の使用
<a name="UsingWithRDS.IAMDBAuth.DBAccounts.MySQL"></a>

MariaDB および MySQL では、認証は、`AWSAuthenticationPlugin` (IAM とシームレスに連携してユーザーを認証する AWS 提供のプラグイン) によって処理されます。DB インスタンスに、マスターユーザーまたはユーザーを作成して権限を付与できる別のユーザーとして接続します。接続後、次の例に示すように、`CREATE USER` ステートメントを発行します。

```
CREATE USER 'jane_doe' IDENTIFIED WITH AWSAuthenticationPlugin AS 'RDS'; 
```

`IDENTIFIED WITH` 句により、MariaDB および MySQL は `AWSAuthenticationPlugin` を使用して、データベースアカウント (`jane_doe`) を認証できます。`AS 'RDS'` 句は、認証方式を参照します。指定したデータベースユーザー名は、IAM データベースアクセスの IAM ポリシー内のリソースと同じであることを確認します。詳細については、「[IAM データベースアクセス用の IAM ポリシーの作成と使用](UsingWithRDS.IAMDBAuth.IAMPolicy.md)」を参照してください。

**注記**  
次のメッセージが表示された場合、AWS が提供するプラグインが、現在の DB インスタンスに使用できないことを意味します。  
`ERROR 1524 (HY000): Plugin 'AWSAuthenticationPlugin' is not loaded`  
このエラーをトラブルシューティングするには、サポートされている設定を使用していること、および DB インスタンスで IAM データベース認証を有効にしていることを確認します。詳細については、「[利用可能なリージョンとバージョン](UsingWithRDS.IAMDBAuth.md#UsingWithRDS.IAMDBAuth.Availability)」および「[IAM データベース認証の有効化と無効化](UsingWithRDS.IAMDBAuth.Enabling.md)」を参照してください。

`AWSAuthenticationPlugin` を使用してアカウントを作成したら、他のデータベースのアカウントと同様に管理します。例えば、`GRANT` および `REVOKE` ステートメントでアカウント特権を変更したり、`ALTER USER` ステートメントでさまざまなアカウント属性を変更したりできます。

IAM を使用する場合、データベースネットワークトラフィックは SSL/TLS を使用して暗号化されます。SSL 接続を許可するには、以下のコマンドでユーザーアカウントを変更します。

```
ALTER USER 'jane_doe'@'%' REQUIRE SSL;     
```

 

## PostgreSQL での IAM 認証の使用
<a name="UsingWithRDS.IAMDBAuth.DBAccounts.PostgreSQL"></a>

 PostgreSQL で IAM 認証を使用するには、マスターユーザーまたはユーザーを作成して権限を付与できる別のユーザーとして DB インスタンスに接続します。接続後、データベースユーザーを作成して、次の例に示すように、ユーザーに `rds_iam` ロールを付与します。

```
CREATE USER db_userx; 
GRANT rds_iam TO db_userx;
```

指定したデータベースユーザー名は、IAM データベースアクセスの IAM ポリシー内のリソースと同じであることを確認します。詳細については、「[IAM データベースアクセス用の IAM ポリシーの作成と使用](UsingWithRDS.IAMDBAuth.IAMPolicy.md)」を参照してください。IAM 認証を使用するには、`rds_iam` ロールを付与する必要があります。ロールのネストされたメンバーシップまたは間接的な付与を使用することもできます。

# IAM 認証を使用した DB インスタンスへの接続
<a name="UsingWithRDS.IAMDBAuth.Connecting"></a>

IAM データベース認証では、DB インスタンスに接続するときに認証トークンを使用します。*認証トークン*は、パスワードの代わりに使用する文字列です。認証トークンを生成した後、期限切れになるまで 15 分間有効です。期限切れのトークンを使用して接続を試みると、接続リクエストは拒否されます。

すべての認証トークンは、AWS 署名バージョン 4 を使用した有効な署名が添付されている必要があります (詳細については、*AWS 全般のリファレンス*の「[Signature Version 4 の署名プロセス](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html)」を参照してください)。AWS CLI や AWS など、AWS SDK for Java とAWS SDK for Python (Boto3) SDK は、作成した各トークンに自動的に署名できます。

別の AWS のサービス (AWS Lambda など) から Amazon RDS に接続するときに、認証トークンを使用できます。トークンを使用することで、コードにパスワードを含めないで済みます。あるいは、AWS SDK を使用して、認証トークンをプログラムで作成して、プログラムで署名することもできます。

IAM 認証トークンに署名した後、Amazon RDS DB インスタンス に接続できます。以下では、コマンドラインツールまたは AWS や AWS SDK for Java などの AWS SDK for Python (Boto3) SDK を使用して、これを行う方法を示しています。

詳細については、以下のブログ投稿を参照してください。
+ [IAM 認証を使用して SQL Workbench/J により Aurora MySQL または Amazon RDS for MySQL に接続する](https://aws.amazon.com/blogs/database/use-iam-authentication-to-connect-with-sql-workbenchj-to-amazon-aurora-mysql-or-amazon-rds-for-mysql/)
+ [pgAdmin Amazon Aurora PostgreSQL または Amazon RDS for PostgreSQL と接続するための IAM 認証の使用](https://aws.amazon.com/blogs/database/using-iam-authentication-to-connect-with-pgadmin-amazon-aurora-postgresql-or-amazon-rds-for-postgresql/)

**前提条件**  
IAM 認証を使用して DB インスタンスに接続するための前提条件は以下のとおりです。
+ [IAM データベース認証の有効化と無効化](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [IAM データベースアクセス用の IAM ポリシーの作成と使用](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [IAM 認証を使用したデータベースアカウントの作成](UsingWithRDS.IAMDBAuth.DBAccounts.md)

**Topics**
+ [

# IAM 認証と AWS ドライバーを使用した DB インスタンスへの接続
](IAMDBAuth.Connecting.Drivers.md)
+ [

# コマンドラインから IAM 認証を使用して、DB インスタンスに接続する: AWS CLI および mysql クライアント
](UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.md)
+ [

# コマンドラインから IAM 認証を使用して DB インスタンスに接続する: AWS CLI および psql クライアント
](UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.PostgreSQL.md)
+ [

# IAM 認証および AWS SDK for .NET を使用した DB インスタンスへの接続
](UsingWithRDS.IAMDBAuth.Connecting.NET.md)
+ [

# IAM 認証および AWS SDK for Go を使用した DB インスタンスへの接続
](UsingWithRDS.IAMDBAuth.Connecting.Go.md)
+ [

# IAM 認証および AWS SDK for Java を使用した DB インスタンスへの接続
](UsingWithRDS.IAMDBAuth.Connecting.Java.md)
+ [

# IAM 認証および AWS SDK for Python (Boto3) を使用した DB インスタンスへの接続
](UsingWithRDS.IAMDBAuth.Connecting.Python.md)

# IAM 認証と AWS ドライバーを使用した DB インスタンスへの接続
<a name="IAMDBAuth.Connecting.Drivers"></a>

AWS のドライバースイートは、スイッチオーバーとフェイルオーバーの時間の短縮、AWS Secrets Manager、AWS Identity and Access Management (IAM)、フェデレーティッド ID での認証をサポートするように設計されています。AWS ドライバーは、DB インスタンスステータスをモニタリングし、インスタンストポロジを認識して新しいライターを決定することを前提としています。このアプローチにより、スイッチオーバーとフェイルオーバーの時間が 1 桁秒に短縮されます (オープンソースドライバーの場合は数十秒)。

AWS ドライバーの詳細については、使用している [RDS for MariaDB](MariaDB.Connecting.Drivers.md#MariaDB.Connecting.JDBCDriver)、[RDS for MySQL](MySQL.Connecting.Drivers.md#MySQL.Connecting.JDBCDriver)、または [RDS for PostgreSQL](PostgreSQL.Connecting.JDBCDriver.md) DB インスタンスに対応する言語ドライバーを参照してください。

**注記**  
RDS for MariaDB でサポートされている機能は、AWS Secrets Manager、AWS Identity and Access Management (IAM)、およびフェデレーティッド ID による認証のみです。

# コマンドラインから IAM 認証を使用して、DB インスタンスに接続する: AWS CLI および mysql クライアント
<a name="UsingWithRDS.IAMDBAuth.Connecting.AWSCLI"></a>

以下に示すように、AWS CLI および `mysql` コマンドラインツールを使用して、コマンドラインから Amazon RDS DB インスタンスに接続できます。

**前提条件**  
IAM 認証を使用して DB インスタンスに接続するための前提条件は以下のとおりです。
+ [IAM データベース認証の有効化と無効化](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [IAM データベースアクセス用の IAM ポリシーの作成と使用](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [IAM 認証を使用したデータベースアカウントの作成](UsingWithRDS.IAMDBAuth.DBAccounts.md)

**注記**  
IAM 認証を使用して SQLWorkbench/J を使用してデータベースに接続する方法については、ブログ記事「[IAM 認証を使用して SQL Workbench/J で Aurora MySQL または Amazon RDS for MySQL に接続する](https://aws.amazon.com/blogs/database/use-iam-authentication-to-connect-with-sql-workbenchj-to-amazon-aurora-mysql-or-amazon-rds-for-mysql/)」を参照してください。

**Topics**
+ [

## IAM 認証トークンの生成
](#UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.AuthToken)
+ [

## DB インスタンスへの接続
](#UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.Connect)

## IAM 認証トークンの生成
<a name="UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.AuthToken"></a>

次の例では、AWS CLI を使用して署名された認証トークンを取得する方法を示します。

```
aws rds generate-db-auth-token \
   --hostname rdsmysql.123456789012.us-west-2.rds.amazonaws.com \
   --port 3306 \
   --region us-west-2 \
   --username jane_doe
```

この例で、パラメータは次のとおりです。
+ `--hostname` - アクセス先の DB インスタンスのホスト名。
+ `--port` - DB インスタンスへの接続に使用するポート番号
+ `--region` - DB インスタンスが実行中の AWS リージョン
+ `--username` - アクセス先のデータベースアカウント

トークンの初期の複数の文字は次のようになります。

```
rdsmysql.123456789012.us-west-2.rds.amazonaws.com:3306/?Action=connect&DBUser=jane_doe&X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Expires=900...
```

**注記**  
DB インスタンス エンドポイントの代わりに、カスタム Route 53 DNS レコードを使用して認証トークンを生成することはできません。

## DB インスタンスへの接続
<a name="UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.Connect"></a>

接続の全般的な形式を次に示します。

```
mysql --host=hostName --port=portNumber --ssl-ca=full_path_to_ssl_certificate --enable-cleartext-plugin --user=userName --password=authToken
```

パラメータは次のとおりです。
+ `--host` - アクセス先の DB インスタンスのホスト名。
+ `--port` - DB インスタンスへの接続に使用するポート番号
+ `--ssl-ca` - 公開キーを含む SSL 証明書ファイルへのフルパス

  MariaDB での SSL/TLS サポートについては、「[Amazon RDS 上の MariaDB DB インスタンスの SSL/TLS サポート](MariaDB.Concepts.SSLSupport.md)」を参照してください。

  MySQL での SSL/TLS サポートについては、「[Amazon RDS 上の MySQL DB インスタンスの SSL/TLS サポート](MySQL.Concepts.SSLSupport.md)」を参照してください。

  SSL 証明書をダウンロードするには [SSL/TLS を使用した DB インスタンスまたはクラスターへの接続の暗号化](UsingWithRDS.SSL.md) を参照ください。
+ `--enable-cleartext-plugin` - この接続で `AWSAuthenticationPlugin` を使用する必要があることを示す値

  MariaDB クライアントを使用している場合、`--enable-cleartext-plugin` オプションは必須ではありません。
+ `--user` - アクセス先のデータベースアカウント
+ `--password` - 署名済みの IAM 認証トークン

認証トークンは数百の文字で構成されます。これは、コマンドラインでは手に負えなくなる可能性があります。この問題を回避する 1 つの方法は、環境可変にトークンを保存し、接続時にその可変を使用することです。次の例は、この回避策を実行する 1 つの方法を示しています。この例では、*/sample\$1dir/* が公開キーを含む SSL 証明書ファイルへのフルパスです。

```
RDSHOST="mysqldb.123456789012.us-east-1.rds.amazonaws.com"
TOKEN="$(aws rds generate-db-auth-token --hostname $RDSHOST --port 3306 --region us-west-2 --username jane_doe )"

mysql --host=$RDSHOST --port=3306 --ssl-ca=/sample_dir/global-bundle.pem --enable-cleartext-plugin --user=jane_doe --password=$TOKEN
```

`AWSAuthenticationPlugin` を使って接続した場合、接続は SSL を使用して保護されます。これを確認するには、`mysql>` コマンドプロンプトで以下を入力します。

```
show status like 'Ssl%';
```

出力の次の行に詳細情報が示されます。

```
+---------------+-------------+
| Variable_name | Value                                                                                                                                                                                                                                |
+---------------+-------------+
| ...           | ...
| Ssl_cipher    | AES256-SHA                                                                                                                                                                                                                           |
| ...           | ...
| Ssl_version   | TLSv1.1                                                                                                                                                                                                                              |
| ...           | ...
+-----------------------------+
```

プロキシ経由で DB インスタンスに接続する場合は、「[IAM 認証を使用したデータベースへの接続](rds-proxy-connecting.md#rds-proxy-connecting-iam)」を参照してください。

# コマンドラインから IAM 認証を使用して DB インスタンスに接続する: AWS CLI および psql クライアント
<a name="UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.PostgreSQL"></a>

以下に示すように、AWS CLI および psql コマンドラインツールを使用して、コマンドラインから Amazon RDS for PostgreSQL DB インスタンスに接続できます。

**前提条件**  
IAM 認証を使用して DB インスタンスに接続するための前提条件は以下のとおりです。
+ [IAM データベース認証の有効化と無効化](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [IAM データベースアクセス用の IAM ポリシーの作成と使用](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [IAM 認証を使用したデータベースアカウントの作成](UsingWithRDS.IAMDBAuth.DBAccounts.md)

**注記**  
pgAdminを使用してIAM認証でデータベースに接続する方法については、ブログ記事[IAM認証を使用してpgAdmin Amazon Aurora PostgreSQLまたはAmazon RDS for PostgreSQLで接続する](https://aws.amazon.com/blogs/database/using-iam-authentication-to-connect-with-pgadmin-amazon-aurora-postgresql-or-amazon-rds-for-postgresql/)を参照してください。

**Topics**
+ [

## IAM 認証トークンの生成
](#UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.AuthToken.PostgreSQL)
+ [

## Amazon RDS PostgreSQL インスタンスへの接続
](#UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.Connect.PostgreSQL)

## IAM 認証トークンの生成
<a name="UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.AuthToken.PostgreSQL"></a>

認証トークンは数百の文字で構成されるため、コマンドラインでは手に負えなくなる可能性があります。この問題を回避する 1 つの方法は、環境可変にトークンを保存し、接続時にその可変を使用することです。次の例では、AWS CLI コマンドを使用して署名された認証トークンを取得するために `generate-db-auth-token` を使用し、`PGPASSWORD` 環境可変に格納する方法を示しています。

```
export RDSHOST="rdspostgres.123456789012.us-west-2.rds.amazonaws.com"
export PGPASSWORD="$(aws rds generate-db-auth-token --hostname $RDSHOST --port 5432 --region us-west-2 --username jane_doe )"
```

例では、`generate-db-auth-token` コマンドへのパラメータは次のとおりです。
+ `--hostname` - アクセス先の DB インスタンス のホスト名
+ `--port` - DB インスタンスへの接続に使用するポート番号
+ `--region` - DB インスタンスが実行中の AWS リージョン
+ `--username` - アクセス先のデータベースアカウント

生成されたトークンの初期の複数の文字は次のようになります。

```
rdspostgres.123456789012.us-west-2.rds.amazonaws.com:5432/?Action=connect&DBUser=jane_doe&X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Expires=900...
```

**注記**  
DB インスタンス エンドポイントの代わりに、カスタム Route 53 DNS レコードを使用して認証トークンを生成することはできません。

## Amazon RDS PostgreSQL インスタンスへの接続
<a name="UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.Connect.PostgreSQL"></a>

psql を使用して接続する全般的な形式を次に示します。

```
psql "host=hostName port=portNumber sslmode=verify-full sslrootcert=full_path_to_ssl_certificate dbname=DBName user=userName password=authToken"
```

パラメータは次のとおりです。
+ `host` - アクセス先の DB インスタンス のホスト名
+ `port` - DB インスタンスへの接続に使用するポート番号
+ `sslmode` - 使用する SSL モード

  `sslmode=verify-full` を使用すると、SSL 接続で DB インスタンスのエンドポイントを SSL 証明書のエンドポイントと照合します。
+ `sslrootcert` －公開キーを含む SSL 証明書ファイルへのフルパス

  詳細については、「[PostgreSQL DB インスタンスで SSL を使用する](PostgreSQL.Concepts.General.SSL.md)」を参照してください。

  SSL 証明書をダウンロードするには [SSL/TLS を使用した DB インスタンスまたはクラスターへの接続の暗号化](UsingWithRDS.SSL.md) を参照ください。
+ `dbname` - アクセス先のデータベース
+ `user` - アクセス先のデータベースアカウント
+ `password` - 署名済みの IAM 認証トークン

**注記**  
DB インスタンス エンドポイントの代わりに、カスタム Route 53 DNS レコードを使用して認証トークンを生成することはできません。

次の例は、psql を使用して接続する方法を示しています。この例の psql では、環境変数 `RDSHOST` をホスト用に、また、環境変数 `PGPASSWORD` を生成されたトークン用に使用しています。また、*/sample\$1dir/* は公開キーを含む SSL 証明書ファイルへの完全なパスを示します。

```
export RDSHOST="rdspostgres.123456789012.us-west-2.rds.amazonaws.com"
export PGPASSWORD="$(aws rds generate-db-auth-token --hostname $RDSHOST --port 5432 --region us-west-2 --username jane_doe )"
                    
psql "host=$RDSHOST port=5432 sslmode=verify-full sslrootcert=/sample_dir/global-bundle.pem dbname=DBName user=jane_doe password=$PGPASSWORD"
```

プロキシ経由で DB インスタンスに接続する場合は、「[IAM 認証を使用したデータベースへの接続](rds-proxy-connecting.md#rds-proxy-connecting-iam)」を参照してください。

# IAM 認証および AWS SDK for .NET を使用した DB インスタンスへの接続
<a name="UsingWithRDS.IAMDBAuth.Connecting.NET"></a>

次に説明するように、AWS SDK for .NET を使用して、RDS for MariaDB、MySQL、または PostgreSQL DB インスタンスに接続できます。

**前提条件**  
IAM 認証を使用して DB インスタンスに接続するための前提条件は以下のとおりです。
+ [IAM データベース認証の有効化と無効化](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [IAM データベースアクセス用の IAM ポリシーの作成と使用](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [IAM 認証を使用したデータベースアカウントの作成](UsingWithRDS.IAMDBAuth.DBAccounts.md)

**例**  
以下のコード例で、認証トークンを生成し、それを使用して DB インスタンスに接続する方法を示します。

このコードサンプルを実行するには、AWS SDK for .NET サイトにある [AWS](https://aws.amazon.com/sdk-for-net/) が必要です。`AWSSDK.CORE` および `AWSSDK.RDS` パッケージが必要です。DB インスタンスに接続するには、MariaDB または MySQL 用の MySqlConnector や PostgreSQL 用の Npgsql など、DB エンジン用の .NET データベースコネクタを使用します。

このコードで MariaDB インスタンスまたは MySQL DB インスタンスに接続します。必要に応じて以下の可変の値を変更します。
+ `server` - アクセス先の DB インスタンスのエンドポイント
+ `user` - アクセス先のデータベースアカウント
+ `database` - アクセス先のデータベース
+ `port` - DB インスタンスへの接続に使用するポート番号
+ `SslMode` - 使用する SSL モード

  `SslMode=Required` を使用すると、SSL 接続で DB インスタンスのエンドポイントを SSL 証明書のエンドポイントと照合します。
+ `SslCa` － Amazon RDS のSSL 証明書へのフルパス

  証明書をダウンロードするには、「[SSL/TLS を使用した DB インスタンスまたはクラスターへの接続の暗号化](UsingWithRDS.SSL.md)」を参照してください。

**注記**  
DB インスタンス エンドポイントの代わりに、カスタム Route 53 DNS レコードを使用して認証トークンを生成することはできません。

```
using System;
using System.Data;
using MySql.Data;
using MySql.Data.MySqlClient;
using Amazon;

namespace ubuntu
{
  class Program
  {
    static void Main(string[] args)
    {
      var pwd = Amazon.RDS.Util.RDSAuthTokenGenerator.GenerateAuthToken(RegionEndpoint.USEast1, "mysqldb.123456789012.us-east-1.rds.amazonaws.com", 3306, "jane_doe");
      // for debug only Console.Write("{0}\n", pwd);  //this verifies the token is generated

      MySqlConnection conn = new MySqlConnection($"server=mysqldb.123456789012.us-east-1.rds.amazonaws.com;user=jane_doe;database=mydB;port=3306;password={pwd};SslMode=Required;SslCa=full_path_to_ssl_certificate");
      conn.Open();

      // Define a query
      MySqlCommand sampleCommand = new MySqlCommand("SHOW DATABASES;", conn);

      // Execute a query
      MySqlDataReader mysqlDataRdr = sampleCommand.ExecuteReader();

      // Read all rows and output the first column in each row
      while (mysqlDataRdr.Read())
        Console.WriteLine(mysqlDataRdr[0]);

      mysqlDataRdr.Close();
      // Close connection
      conn.Close();
    }
  }
}
```

このコードで PostgreSQL DB インスタンスに接続します。

必要に応じて以下の可変の値を変更します。
+ `Server` - アクセス先の DB インスタンスのエンドポイント
+ `User ID` - アクセス先のデータベースアカウント
+ `Database` - アクセス先のデータベース
+ `Port` - DB インスタンスへの接続に使用するポート番号
+ `SSL Mode` - 使用する SSL モード

  `SSL Mode=Required` を使用すると、SSL 接続で DB インスタンスのエンドポイントを SSL 証明書のエンドポイントと照合します。
+ `Root Certificate` － Amazon RDS のSSL 証明書へのフルパス

  証明書をダウンロードするには、「[SSL/TLS を使用した DB インスタンスまたはクラスターへの接続の暗号化](UsingWithRDS.SSL.md)」を参照してください。

**注記**  
DB インスタンス エンドポイントの代わりに、カスタム Route 53 DNS レコードを使用して認証トークンを生成することはできません。

```
using System;
using Npgsql;
using Amazon.RDS.Util;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            var pwd = RDSAuthTokenGenerator.GenerateAuthToken("postgresmydb.123456789012.us-east-1.rds.amazonaws.com", 5432, "jane_doe");
// for debug only Console.Write("{0}\n", pwd);  //this verifies the token is generated

            NpgsqlConnection conn = new NpgsqlConnection($"Server=postgresmydb.123456789012.us-east-1.rds.amazonaws.com;User Id=jane_doe;Password={pwd};Database=mydb;SSL Mode=Require;Root Certificate=full_path_to_ssl_certificate");
            conn.Open();

            // Define a query
                   NpgsqlCommand cmd = new NpgsqlCommand("select count(*) FROM pg_user", conn);

            // Execute a query
            NpgsqlDataReader dr = cmd.ExecuteReader();

            // Read all rows and output the first column in each row
            while (dr.Read())
                Console.Write("{0}\n", dr[0]);

            // Close connection
            conn.Close();
        }
    }
}
```

プロキシ経由で DB インスタンスに接続する場合は、「[IAM 認証を使用したデータベースへの接続](rds-proxy-connecting.md#rds-proxy-connecting-iam)」を参照してください。

# IAM 認証および AWS SDK for Go を使用した DB インスタンスへの接続
<a name="UsingWithRDS.IAMDBAuth.Connecting.Go"></a>

次に説明するように、AWS SDK for Go を使用して、RDS for MariaDB、MySQL、または PostgreSQL DB インスタンスに接続できます。

**前提条件**  
IAM 認証を使用して DB インスタンスに接続するための前提条件は以下のとおりです。
+ [IAM データベース認証の有効化と無効化](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [IAM データベースアクセス用の IAM ポリシーの作成と使用](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [IAM 認証を使用したデータベースアカウントの作成](UsingWithRDS.IAMDBAuth.DBAccounts.md)

**例**  
これらのコードサンプルを実行するには、AWS SDK for Go サイトにある [AWS](https://aws.amazon.com/sdk-for-go/) が必要です。

必要に応じて以下の可変の値を変更します。
+ `dbName` - アクセス先のデータベース
+ `dbUser` - アクセス先のデータベースアカウント
+ `dbHost` - アクセス先の DB インスタンスのエンドポイント
**注記**  
DB インスタンス エンドポイントの代わりに、カスタム Route 53 DNS レコードを使用して認証トークンを生成することはできません。
+ `dbPort` - DB インスタンスへの接続に使用するポート番号
+ `region` - DB インスタンスが実行中の AWS リージョン

さらに、サンプルコード内のインポートされるライブラリがシステムに存在することを確認してください。

**重要**  
このセクションの例では、次のコードを使用して、ローカル環境からデータベースにアクセスする認証情報を提供します。  
`creds := credentials.NewEnvCredentials()`  
Amazon EC2 や Amazon ECS などの AWS のサービスからデータベースにアクセスする場合は、コードを次のコードに置き換えることができます。  
`sess := session.Must(session.NewSession())`  
`creds := sess.Config.Credentials`  
この変更を行う場合は、次のインポートを追加してください。  
`"github.com/aws/aws-sdk-go/aws/session"`

**Topics**
+ [

## IAM 認証と AWS SDK for Go V2 を使用した接続
](#UsingWithRDS.IAMDBAuth.Connecting.GoV2)
+ [

## IAM 認証と AWS SDK for Go V1 を使用した接続。
](#UsingWithRDS.IAMDBAuth.Connecting.GoV1)

## IAM 認証と AWS SDK for Go V2 を使用した接続
<a name="UsingWithRDS.IAMDBAuth.Connecting.GoV2"></a>

IAM 認証と AWS SDK for Go V2 を使用して DB インスタンスに接続できます

以下のコード例で、認証トークンを生成し、それを使用して DB インスタンスに接続する方法を示します。

このコードで MariaDB インスタンスまたは MySQL DB インスタンスに接続します。

```
package main
                
import (
     "context"
     "database/sql"
     "fmt"

     "github.com/aws/aws-sdk-go-v2/config"
     "github.com/aws/aws-sdk-go-v2/feature/rds/auth"
     _ "github.com/go-sql-driver/mysql"
)

func main() {

     var dbName string = "DatabaseName"
     var dbUser string = "DatabaseUser"
     var dbHost string = "mysqldb.123456789012.us-east-1.rds.amazonaws.com"
     var dbPort int = 3306
     var dbEndpoint string = fmt.Sprintf("%s:%d", dbHost, dbPort)
     var region string = "us-east-1"

    cfg, err := config.LoadDefaultConfig(context.TODO())
    if err != nil {
    	panic("configuration error: " + err.Error())
    }

    authenticationToken, err := auth.BuildAuthToken(
    	context.TODO(), dbEndpoint, region, dbUser, cfg.Credentials)
    if err != nil {
	    panic("failed to create authentication token: " + err.Error())
    }

    dsn := fmt.Sprintf("%s:%s@tcp(%s)/%s?tls=true&allowCleartextPasswords=true",
        dbUser, authenticationToken, dbEndpoint, dbName,
    )

    db, err := sql.Open("mysql", dsn)
    if err != nil {
        panic(err)
    }

    err = db.Ping()
    if err != nil {
        panic(err)
    }
}
```

このコードで PostgreSQL DB インスタンスに接続します。

```
package main

import (
     "context"
     "database/sql"
     "fmt"

     "github.com/aws/aws-sdk-go-v2/config"
     "github.com/aws/aws-sdk-go-v2/feature/rds/auth"
     _ "github.com/lib/pq"
)

func main() {

     var dbName string = "DatabaseName"
     var dbUser string = "DatabaseUser"
     var dbHost string = "postgresmydb.123456789012.us-east-1.rds.amazonaws.com"
     var dbPort int = 5432
     var dbEndpoint string = fmt.Sprintf("%s:%d", dbHost, dbPort)
     var region string = "us-east-1"

    cfg, err := config.LoadDefaultConfig(context.TODO())
    if err != nil {
    	panic("configuration error: " + err.Error())
    }

    authenticationToken, err := auth.BuildAuthToken(
    	context.TODO(), dbEndpoint, region, dbUser, cfg.Credentials)
    if err != nil {
	    panic("failed to create authentication token: " + err.Error())
    }

    dsn := fmt.Sprintf("host=%s port=%d user=%s password=%s dbname=%s",
        dbHost, dbPort, dbUser, authenticationToken, dbName,
    )

    db, err := sql.Open("postgres", dsn)
    if err != nil {
        panic(err)
    }

    err = db.Ping()
    if err != nil {
        panic(err)
    }
}
```

プロキシ経由で DB インスタンスに接続する場合は、「[IAM 認証を使用したデータベースへの接続](rds-proxy-connecting.md#rds-proxy-connecting-iam)」を参照してください。

## IAM 認証と AWS SDK for Go V1 を使用した接続。
<a name="UsingWithRDS.IAMDBAuth.Connecting.GoV1"></a>

IAM 認証と AWS SDK for Go V1 を使用して DB インスタンスに接続できます

以下のコード例で、認証トークンを生成し、それを使用して DB インスタンスに接続する方法を示します。

このコードで MariaDB インスタンスまたは MySQL DB インスタンスに接続します。

```
package main
         
import (
    "database/sql"
    "fmt"
    "log"

    "github.com/aws/aws-sdk-go/aws/credentials"
    "github.com/aws/aws-sdk-go/service/rds/rdsutils"
    _ "github.com/go-sql-driver/mysql"
)

func main() {
    dbName := "app"
    dbUser := "jane_doe"
    dbHost := "mysqldb.123456789012.us-east-1.rds.amazonaws.com"
    dbPort := 3306
    dbEndpoint := fmt.Sprintf("%s:%d", dbHost, dbPort)
    region := "us-east-1"

    creds := credentials.NewEnvCredentials()
    authToken, err := rdsutils.BuildAuthToken(dbEndpoint, region, dbUser, creds)
    if err != nil {
        panic(err)
    }

    dsn := fmt.Sprintf("%s:%s@tcp(%s)/%s?tls=true&allowCleartextPasswords=true",
        dbUser, authToken, dbEndpoint, dbName,
    )

    db, err := sql.Open("mysql", dsn)
    if err != nil {
        panic(err)
    }

    err = db.Ping()
    if err != nil {
        panic(err)
    }
}
```

このコードで PostgreSQL DB インスタンスに接続します。

```
package main

import (
	"database/sql"
	"fmt"

	"github.com/aws/aws-sdk-go/aws/credentials"
	"github.com/aws/aws-sdk-go/service/rds/rdsutils"
	_ "github.com/lib/pq"
)

func main() {
    dbName := "app"
    dbUser := "jane_doe"
    dbHost := "postgresmydb.123456789012.us-east-1.rds.amazonaws.com"
    dbPort := 5432
    dbEndpoint := fmt.Sprintf("%s:%d", dbHost, dbPort)
    region := "us-east-1"

    creds := credentials.NewEnvCredentials()
    authToken, err := rdsutils.BuildAuthToken(dbEndpoint, region, dbUser, creds)
    if err != nil {
        panic(err)
    }

    dsn := fmt.Sprintf("host=%s port=%d user=%s password=%s dbname=%s",
        dbHost, dbPort, dbUser, authToken, dbName,
    )

    db, err := sql.Open("postgres", dsn)
    if err != nil {
        panic(err)
    }

    err = db.Ping()
    if err != nil {
        panic(err)
    }
}
```

プロキシ経由で DB インスタンスに接続する場合は、「[IAM 認証を使用したデータベースへの接続](rds-proxy-connecting.md#rds-proxy-connecting-iam)」を参照してください。

# IAM 認証および AWS SDK for Java を使用した DB インスタンスへの接続
<a name="UsingWithRDS.IAMDBAuth.Connecting.Java"></a>

次に説明するように、AWS SDK for Java を使用して、RDS for MariaDB、MySQL、または PostgreSQL DB インスタンスに接続できます。

**前提条件**  
IAM 認証を使用して DB インスタンスに接続するための前提条件は以下のとおりです。
+ [IAM データベース認証の有効化と無効化](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [IAM データベースアクセス用の IAM ポリシーの作成と使用](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [IAM 認証を使用したデータベースアカウントの作成](UsingWithRDS.IAMDBAuth.DBAccounts.md)
+ [AWS SDK for Java をセットアップする](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/setup-install.html)

SDK for Java 2.x の使用方法の例については、「[SDK for Java 2.x を使用した Amazon RDS の例](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/java_rds_code_examples.html)」を参照してください。AWS Advanced JDBC Wrapper を使用することもできます。「[AWS Advanced JDBC Wrapper ドキュメント](https://github.com/aws/aws-advanced-jdbc-wrapper/blob/main/docs/Documentation.md)」を参照してください。

**Topics**
+ [

## IAM 認証トークンの生成
](#UsingWithRDS.IAMDBAuth.Connecting.Java.AuthToken)
+ [

## IAM 認証トークンを手動で構築する
](#UsingWithRDS.IAMDBAuth.Connecting.Java.AuthToken2)
+ [

## DB インスタンスへの接続
](#UsingWithRDS.IAMDBAuth.Connecting.Java.AuthToken.Connect)

## IAM 認証トークンの生成
<a name="UsingWithRDS.IAMDBAuth.Connecting.Java.AuthToken"></a>

AWS SDK for Java を使用してプログラムを作成する場合、`RdsIamAuthTokenGenerator` クラスを使用して署名付き認証トークンを取得できます。このクラスを使用するには、AWS 認証情報を提供する必要があります。これを行うには、`DefaultAWSCredentialsProviderChain` クラスのインスタンスを作成します。`DefaultAWSCredentialsProviderChain` は、[デフォルトの認証情報プロバイダチェーン](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/credentials.html#credentials-default)で見つける初期の AWS のアクセスキーとシークレットキーを使用します。AWS アクセスキーの詳細については、「[ユーザーのアクセスキーの管理](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html)」を参照してください。

**注記**  
DB インスタンス エンドポイントの代わりに、カスタム Route 53 DNS レコードを使用して認証トークンを生成することはできません。

`RdsIamAuthTokenGenerator` のインスタンスを作成した後、`getAuthToken` メソッドを呼び出して、署名済みトークンを取得できます。AWS リージョン、ホスト名、ポート番号、およびユーザー名を指定します。次のコード例はこれを行う方法を示しています。

```
package com.amazonaws.codesamples;

import com.amazonaws.auth.DefaultAWSCredentialsProviderChain;
import com.amazonaws.services.rds.auth.GetIamAuthTokenRequest;
import com.amazonaws.services.rds.auth.RdsIamAuthTokenGenerator;

public class GenerateRDSAuthToken {

    public static void main(String[] args) {

	    String region = "us-west-2";
	    String hostname = "rdsmysql.123456789012.us-west-2.rds.amazonaws.com";
	    String port = "3306";
	    String username = "jane_doe";
	
	    System.out.println(generateAuthToken(region, hostname, port, username));
    }

    static String generateAuthToken(String region, String hostName, String port, String username) {

	    RdsIamAuthTokenGenerator generator = RdsIamAuthTokenGenerator.builder()
		    .credentials(new DefaultAWSCredentialsProviderChain())
		    .region(region)
		    .build();

	    String authToken = generator.getAuthToken(
		    GetIamAuthTokenRequest.builder()
		    .hostname(hostName)
		    .port(Integer.parseInt(port))
		    .userName(username)
		    .build());
	    
	    return authToken;
    }

}
```

## IAM 認証トークンを手動で構築する
<a name="UsingWithRDS.IAMDBAuth.Connecting.Java.AuthToken2"></a>

Java では、認証トークンを生成するための最も簡単な方法は、`RdsIamAuthTokenGenerator` を使用することです。このクラスは、認証トークンを作成した後、AWS 署名バージョン 4 を使用してサインインします。詳細については、*AWS 全般のリファレンス*の「[Signature Version 4 の署名プロセス](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html)」を参照してください。

ただし、次のコード例に示すように、認証トークンを手動で構築して署名できます。

```
package com.amazonaws.codesamples;

import com.amazonaws.SdkClientException;
import com.amazonaws.auth.DefaultAWSCredentialsProviderChain;
import com.amazonaws.auth.SigningAlgorithm;
import com.amazonaws.util.BinaryUtils;
import org.apache.commons.lang3.StringUtils;

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.Charset;
import java.security.MessageDigest;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.SortedMap;
import java.util.TreeMap;

import static com.amazonaws.auth.internal.SignerConstants.AWS4_TERMINATOR;
import static com.amazonaws.util.StringUtils.UTF8;

public class CreateRDSAuthTokenManually {
    public static String httpMethod = "GET";
    public static String action = "connect";
    public static String canonicalURIParameter = "/";
    public static SortedMap<String, String> canonicalQueryParameters = new TreeMap();
    public static String payload = StringUtils.EMPTY;
    public static String signedHeader = "host";
    public static String algorithm = "AWS4-HMAC-SHA256";
    public static String serviceName = "rds-db";
    public static String requestWithoutSignature;

    public static void main(String[] args) throws Exception {

        String region = "us-west-2";
        String instanceName = "rdsmysql.123456789012.us-west-2.rds.amazonaws.com";
        String port = "3306";
        String username = "jane_doe";
	
        Date now = new Date();
        String date = new SimpleDateFormat("yyyyMMdd").format(now);
        String dateTimeStamp = new SimpleDateFormat("yyyyMMdd'T'HHmmss'Z'").format(now);
        DefaultAWSCredentialsProviderChain creds = new DefaultAWSCredentialsProviderChain();
	    String awsAccessKey = creds.getCredentials().getAWSAccessKeyId();
	    String awsSecretKey = creds.getCredentials().getAWSSecretKey();
        String expiryMinutes = "900";
        
        System.out.println("Step 1:  Create a canonical request:");
        String canonicalString = createCanonicalString(username, awsAccessKey, date, dateTimeStamp, region, expiryMinutes, instanceName, port);
        System.out.println(canonicalString);
        System.out.println();

        System.out.println("Step 2:  Create a string to sign:");        
        String stringToSign = createStringToSign(dateTimeStamp, canonicalString, awsAccessKey, date, region);
        System.out.println(stringToSign);
        System.out.println();

        System.out.println("Step 3:  Calculate the signature:");        
        String signature = BinaryUtils.toHex(calculateSignature(stringToSign, newSigningKey(awsSecretKey, date, region, serviceName)));
        System.out.println(signature);
        System.out.println();

        System.out.println("Step 4:  Add the signing info to the request");                
        System.out.println(appendSignature(signature));
        System.out.println();
        
    }

    //Step 1: Create a canonical request date should be in format YYYYMMDD and dateTime should be in format YYYYMMDDTHHMMSSZ
    public static String createCanonicalString(String user, String accessKey, String date, String dateTime, String region, String expiryPeriod, String hostName, String port) throws Exception {
        canonicalQueryParameters.put("Action", action);
        canonicalQueryParameters.put("DBUser", user);
        canonicalQueryParameters.put("X-Amz-Algorithm", "AWS4-HMAC-SHA256");
        canonicalQueryParameters.put("X-Amz-Credential", accessKey + "%2F" + date + "%2F" + region + "%2F" + serviceName + "%2Faws4_request");
        canonicalQueryParameters.put("X-Amz-Date", dateTime);
        canonicalQueryParameters.put("X-Amz-Expires", expiryPeriod);
        canonicalQueryParameters.put("X-Amz-SignedHeaders", signedHeader);
        String canonicalQueryString = "";
        while(!canonicalQueryParameters.isEmpty()) {
            String currentQueryParameter = canonicalQueryParameters.firstKey();
            String currentQueryParameterValue = canonicalQueryParameters.remove(currentQueryParameter);
            canonicalQueryString = canonicalQueryString + currentQueryParameter + "=" + currentQueryParameterValue;
            if (!currentQueryParameter.equals("X-Amz-SignedHeaders")) {
                canonicalQueryString += "&";
            }
        }
        String canonicalHeaders = "host:" + hostName + ":" + port + '\n';
        requestWithoutSignature = hostName + ":" + port + "/?" + canonicalQueryString;

        String hashedPayload = BinaryUtils.toHex(hash(payload));
        return httpMethod + '\n' + canonicalURIParameter + '\n' + canonicalQueryString + '\n' + canonicalHeaders + '\n' + signedHeader + '\n' + hashedPayload;

    }

    //Step 2: Create a string to sign using sig v4
    public static String createStringToSign(String dateTime, String canonicalRequest, String accessKey, String date, String region) throws Exception {
        String credentialScope = date + "/" + region + "/" + serviceName + "/aws4_request";
        return algorithm + '\n' + dateTime + '\n' + credentialScope + '\n' + BinaryUtils.toHex(hash(canonicalRequest));

    }

    //Step 3: Calculate signature
    /**
     * Step 3 of the &AWS; Signature version 4 calculation. It involves deriving
     * the signing key and computing the signature. Refer to
     * http://docs.aws.amazon
     * .com/general/latest/gr/sigv4-calculate-signature.html
     */
    public static byte[] calculateSignature(String stringToSign,
                                            byte[] signingKey) {
        return sign(stringToSign.getBytes(Charset.forName("UTF-8")), signingKey,
                SigningAlgorithm.HmacSHA256);
    }

    public static byte[] sign(byte[] data, byte[] key,
                          SigningAlgorithm algorithm) throws SdkClientException {
        try {
            Mac mac = algorithm.getMac();
            mac.init(new SecretKeySpec(key, algorithm.toString()));
            return mac.doFinal(data);
        } catch (Exception e) {
            throw new SdkClientException(
                    "Unable to calculate a request signature: "
                            + e.getMessage(), e);
        }
    }

    public static byte[] newSigningKey(String secretKey,
                                   String dateStamp, String regionName, String serviceName) {
        byte[] kSecret = ("AWS4" + secretKey).getBytes(Charset.forName("UTF-8"));
        byte[] kDate = sign(dateStamp, kSecret, SigningAlgorithm.HmacSHA256);
        byte[] kRegion = sign(regionName, kDate, SigningAlgorithm.HmacSHA256);
        byte[] kService = sign(serviceName, kRegion,
                SigningAlgorithm.HmacSHA256);
        return sign(AWS4_TERMINATOR, kService, SigningAlgorithm.HmacSHA256);
    }

    public static byte[] sign(String stringData, byte[] key,
                       SigningAlgorithm algorithm) throws SdkClientException {
        try {
            byte[] data = stringData.getBytes(UTF8);
            return sign(data, key, algorithm);
        } catch (Exception e) {
            throw new SdkClientException(
                    "Unable to calculate a request signature: "
                            + e.getMessage(), e);
        }
    }

    //Step 4: append the signature
    public static String appendSignature(String signature) {
        return requestWithoutSignature + "&X-Amz-Signature=" + signature;
    }

    public static byte[] hash(String s) throws Exception {
        try {
            MessageDigest md = MessageDigest.getInstance("SHA-256");
            md.update(s.getBytes(UTF8));
            return md.digest();
        } catch (Exception e) {
            throw new SdkClientException(
                    "Unable to compute hash while signing request: "
                            + e.getMessage(), e);
        }
    }
}
```

## DB インスタンスへの接続
<a name="UsingWithRDS.IAMDBAuth.Connecting.Java.AuthToken.Connect"></a>

次のコード例では、認証トークンを生成し、それを使用して MariaDB または MySQL を実行しているインスタンスに接続する方法を示しています。

このコードサンプルを実行するには、AWS SDK for Java サイトにある [AWS](https://aws.amazon.com/sdk-for-java/) が必要です。また、以下が必要になります。
+ MySQL Connector/J。 このコードの例は `mysql-connector-java-5.1.33-bin.jar` でテストされています。
+ AWS リージョンに固有の、Amazon RDS の中間証明書。(詳細については、[SSL/TLS を使用した DB インスタンスまたはクラスターへの接続の暗号化](UsingWithRDS.SSL.md) を参照してください)。クラスローダーは、実行時にこの Java コード例と同じディレクトリで証明書を探し、クラスローダーがその証明書を見つけられるようにします。
+ 必要に応じて以下の可変の値を変更します。
  + `RDS_INSTANCE_HOSTNAME` - アクセス先の DB インスタンスのホスト名。
  + `RDS_INSTANCE_PORT` - PostgreSQL DB インスタンスへの接続に使用されるポート番号。
  + `REGION_NAME` - DB インスタンスが実行中の AWS リージョン
  + `DB_USER` - アクセス先のデータベースアカウント。
  + `SSL_CERTIFICATE` - AWS リージョンに固有の、Amazon RDS の SSL 証明書。

    AWS リージョンの証明書をダウンロードするには、[SSL/TLS を使用した DB インスタンスまたはクラスターへの接続の暗号化](UsingWithRDS.SSL.md) を参照してください。この Java プログラムファイルと同じディレクトリに SSL 証明書を配置し、クラスローダーが実行時にその証明書を見つけられるようにします。

このコード例では、[デフォルトの認証情報プロバイダチェーン](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/credentials.html#credentials-default)から AWS 認証情報を取得します。

**注記**  
セキュリティ上のベストプラクティスとして、ここに示されているプロンプト以外の `DEFAULT_KEY_STORE_PASSWORD` のパスワードを指定してください。

```
package com.amazonaws.samples;

import com.amazonaws.services.rds.auth.RdsIamAuthTokenGenerator;
import com.amazonaws.services.rds.auth.GetIamAuthTokenRequest;
import com.amazonaws.auth.BasicAWSCredentials;
import com.amazonaws.auth.DefaultAWSCredentialsProviderChain;
import com.amazonaws.auth.AWSStaticCredentialsProvider;

import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.security.KeyStore;
import java.security.cert.CertificateFactory;
import java.security.cert.X509Certificate;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.Properties;

import java.net.URL;

public class IAMDatabaseAuthenticationTester {
    //&AWS; Credentials of the IAM user with policy enabling IAM Database Authenticated access to the db by the db user.
    private static final DefaultAWSCredentialsProviderChain creds = new DefaultAWSCredentialsProviderChain();
    private static final String AWS_ACCESS_KEY = creds.getCredentials().getAWSAccessKeyId();
    private static final String AWS_SECRET_KEY = creds.getCredentials().getAWSSecretKey();

    //Configuration parameters for the generation of the IAM Database Authentication token
    private static final String RDS_INSTANCE_HOSTNAME = "rdsmysql.123456789012.us-west-2.rds.amazonaws.com";
    private static final int RDS_INSTANCE_PORT = 3306;
    private static final String REGION_NAME = "us-west-2";
    private static final String DB_USER = "jane_doe";
    private static final String JDBC_URL = "jdbc:mysql://" + RDS_INSTANCE_HOSTNAME + ":" + RDS_INSTANCE_PORT;

    private static final String SSL_CERTIFICATE = "rds-ca-2019-us-west-2.pem";

    private static final String KEY_STORE_TYPE = "JKS";
    private static final String KEY_STORE_PROVIDER = "SUN";
    private static final String KEY_STORE_FILE_PREFIX = "sys-connect-via-ssl-test-cacerts";
    private static final String KEY_STORE_FILE_SUFFIX = ".jks";
    private static final String DEFAULT_KEY_STORE_PASSWORD = "changeit";

    public static void main(String[] args) throws Exception {
        //get the connection
        Connection connection = getDBConnectionUsingIam();

        //verify the connection is successful
        Statement stmt= connection.createStatement();
        ResultSet rs=stmt.executeQuery("SELECT 'Success!' FROM DUAL;");
        while (rs.next()) {
        	    String id = rs.getString(1);
            System.out.println(id); //Should print "Success!"
        }

        //close the connection
        stmt.close();
        connection.close();
        
        clearSslProperties();
        
    }

    /**
     * This method returns a connection to the db instance authenticated using IAM Database Authentication
     * @return
     * @throws Exception
     */
    private static Connection getDBConnectionUsingIam() throws Exception {
        setSslProperties();
        return DriverManager.getConnection(JDBC_URL, setMySqlConnectionProperties());
    }

    /**
     * This method sets the mysql connection properties which includes the IAM Database Authentication token
     * as the password. It also specifies that SSL verification is required.
     * @return
     */
    private static Properties setMySqlConnectionProperties() {
        Properties mysqlConnectionProperties = new Properties();
        mysqlConnectionProperties.setProperty("verifyServerCertificate","true");
        mysqlConnectionProperties.setProperty("useSSL", "true");
        mysqlConnectionProperties.setProperty("user",DB_USER);
        mysqlConnectionProperties.setProperty("password",generateAuthToken());
        return mysqlConnectionProperties;
    }

    /**
     * This method generates the IAM Auth Token.
     * An example IAM Auth Token would look like follows:
     * btusi123---cmz7kenwo2ye---rds---cn-north-1.amazonaws.com.rproxy.goskope.com.cn:3306/?Action=connect&DBUser=iamtestuser&X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Date=20171003T010726Z&X-Amz-SignedHeaders=host&X-Amz-Expires=899&X-Amz-Credential=AKIAPFXHGVDI5RNFO4AQ%2F20171003%2Fcn-north-1%2Frds-db%2Faws4_request&X-Amz-Signature=f9f45ef96c1f770cdad11a53e33ffa4c3730bc03fdee820cfdf1322eed15483b
     * @return
     */
    private static String generateAuthToken() {
        BasicAWSCredentials awsCredentials = new BasicAWSCredentials(AWS_ACCESS_KEY, AWS_SECRET_KEY);

        RdsIamAuthTokenGenerator generator = RdsIamAuthTokenGenerator.builder()
                .credentials(new AWSStaticCredentialsProvider(awsCredentials)).region(REGION_NAME).build();
        return generator.getAuthToken(GetIamAuthTokenRequest.builder()
                .hostname(RDS_INSTANCE_HOSTNAME).port(RDS_INSTANCE_PORT).userName(DB_USER).build());
    }

    /**
     * This method sets the SSL properties which specify the key store file, its type and password:
     * @throws Exception
     */
    private static void setSslProperties() throws Exception {
        System.setProperty("javax.net.ssl.trustStore", createKeyStoreFile());
        System.setProperty("javax.net.ssl.trustStoreType", KEY_STORE_TYPE);
        System.setProperty("javax.net.ssl.trustStorePassword", DEFAULT_KEY_STORE_PASSWORD);
    }

    /**
     * This method returns the path of the Key Store File needed for the SSL verification during the IAM Database Authentication to
     * the db instance.
     * @return
     * @throws Exception
     */
    private static String createKeyStoreFile() throws Exception {
        return createKeyStoreFile(createCertificate()).getPath();
    }

    /**
     *  This method generates the SSL certificate
     * @return
     * @throws Exception
     */
    private static X509Certificate createCertificate() throws Exception {
        CertificateFactory certFactory = CertificateFactory.getInstance("X.509");
        URL url = new File(SSL_CERTIFICATE).toURI().toURL();
        if (url == null) {
            throw new Exception();
        }
        try (InputStream certInputStream = url.openStream()) {
            return (X509Certificate) certFactory.generateCertificate(certInputStream);
        }
    }

    /**
     * This method creates the Key Store File
     * @param rootX509Certificate - the SSL certificate to be stored in the KeyStore
     * @return
     * @throws Exception
     */
    private static File createKeyStoreFile(X509Certificate rootX509Certificate) throws Exception {
        File keyStoreFile = File.createTempFile(KEY_STORE_FILE_PREFIX, KEY_STORE_FILE_SUFFIX);
        try (FileOutputStream fos = new FileOutputStream(keyStoreFile.getPath())) {
            KeyStore ks = KeyStore.getInstance(KEY_STORE_TYPE, KEY_STORE_PROVIDER);
            ks.load(null);
            ks.setCertificateEntry("rootCaCertificate", rootX509Certificate);
            ks.store(fos, DEFAULT_KEY_STORE_PASSWORD.toCharArray());
        }
        return keyStoreFile;
    }
    
    /**
     * This method clears the SSL properties.
     * @throws Exception
     */
    private static void clearSslProperties() throws Exception {
           System.clearProperty("javax.net.ssl.trustStore");
           System.clearProperty("javax.net.ssl.trustStoreType");
           System.clearProperty("javax.net.ssl.trustStorePassword"); 
    }
    
}
```

プロキシ経由で DB インスタンスに接続する場合は、「[IAM 認証を使用したデータベースへの接続](rds-proxy-connecting.md#rds-proxy-connecting-iam)」を参照してください。

# IAM 認証および AWS SDK for Python (Boto3) を使用した DB インスタンスへの接続
<a name="UsingWithRDS.IAMDBAuth.Connecting.Python"></a>

次に説明するように、AWS SDK for Python (Boto3) を使用して、RDS for MariaDB、MySQL、または PostgreSQL DB インスタンスに接続できます。

**前提条件**  
IAM 認証を使用して DB インスタンスに接続するための前提条件は以下のとおりです。
+ [IAM データベース認証の有効化と無効化](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [IAM データベースアクセス用の IAM ポリシーの作成と使用](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [IAM 認証を使用したデータベースアカウントの作成](UsingWithRDS.IAMDBAuth.DBAccounts.md)

さらに、サンプルコード内のインポートされるライブラリがシステムに存在することを確認してください。

**例**  
コード例では、共有認証情報のプロファイルを使用します。認証情報の指定については、AWS SDK for Python (Boto3) ドキュメントの「[認証情報](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/credentials.html)」を参照してください。

以下のコード例で、認証トークンを生成し、それを使用して DB インスタンスに接続する方法を示します。

このコードサンプルを実行するには、AWS SDK for Python (Boto3) サイトにある [AWS](https://aws.amazon.com/sdk-for-python/) が必要です。

必要に応じて以下の可変の値を変更します。
+ `ENDPOINT` - アクセス先の DB インスタンスのエンドポイント
+ `PORT` - DB インスタンスへの接続に使用するポート番号
+ `USER` - アクセス先のデータベースアカウント
+ `REGION` - DB インスタンスが実行中の AWS リージョン
+ `DBNAME` - アクセス先のデータベース
+ `SSLCERTIFICATE` － Amazon RDS の SSL 証明書へのフルパス

  `ssl_ca` を使用する場合、SSL 証明書を指定します。SSL 証明書をダウンロードするには [SSL/TLS を使用した DB インスタンスまたはクラスターへの接続の暗号化](UsingWithRDS.SSL.md) を参照ください。

**注記**  
DB インスタンス エンドポイントの代わりに、カスタム Route 53 DNS レコードを使用して認証トークンを生成することはできません。

このコードで MariaDB インスタンスまたは MySQL DB インスタンスに接続します。

このコードを実行する前に、[Python Package Index](https://pypi.org/project/PyMySQL/) の手順に従って PyMySQL ドライバーをインストールしてください。

```
import pymysql
import sys
import boto3
import os

ENDPOINT="mysqldb.123456789012.us-east-1.rds.amazonaws.com"
PORT="3306"
USER="jane_doe"
REGION="us-east-1"
DBNAME="mydb"
os.environ['LIBMYSQL_ENABLE_CLEARTEXT_PLUGIN'] = '1'

#gets the credentials from .aws/credentials
session = boto3.Session(profile_name='default')
client = session.client('rds')

token = client.generate_db_auth_token(DBHostname=ENDPOINT, Port=PORT, DBUsername=USER, Region=REGION)

try:
    conn =  pymysql.connect(auth_plugin_map={'mysql_clear_password':None},host=ENDPOINT, user=USER, password=token, port=PORT, database=DBNAME, ssl_ca='SSLCERTIFICATE', ssl_verify_identity=True, ssl_verify_cert=True)
    cur = conn.cursor()
    cur.execute("""SELECT now()""")
    query_results = cur.fetchall()
    print(query_results)
except Exception as e:
    print("Database connection failed due to {}".format(e))
```

このコードで PostgreSQL DB インスタンスに接続します。

このコードを実行する前に、[Psycopg documentation](https://pypi.org/project/psycopg2/) の手順に従って `psycopg2` をインストールしてください。

```
import psycopg2
import sys
import boto3
import os

ENDPOINT="postgresmydb.123456789012.us-east-1.rds.amazonaws.com"
PORT="5432"
USER="jane_doe"
REGION="us-east-1"
DBNAME="mydb"

#gets the credentials from .aws/credentials
session = boto3.Session(profile_name='RDSCreds')
client = session.client('rds')

token = client.generate_db_auth_token(DBHostname=ENDPOINT, Port=PORT, DBUsername=USER, Region=REGION)

try:
    conn = psycopg2.connect(host=ENDPOINT, port=PORT, database=DBNAME, user=USER, password=token, sslrootcert="SSLCERTIFICATE")
    cur = conn.cursor()
    cur.execute("""SELECT now()""")
    query_results = cur.fetchall()
    print(query_results)
except Exception as e:
    print("Database connection failed due to {}".format(e))
```

プロキシ経由で DB インスタンスに接続する場合は、「[IAM 認証を使用したデータベースへの接続](rds-proxy-connecting.md#rds-proxy-connecting-iam)」を参照してください。

# IAM DB 認証のトラブルシューティング
<a name="UsingWithRDS.IAMDBAuth.Troubleshooting"></a>

以下に、いくつかの一般的な IAM DB 認証に関する問題のトラブルシューティングのヒントと、IAM DB 認証の CloudWatch ログおよびメトリクスに関する情報を示します。

## CloudWatch Logs への IAM DB 認証エラーログのエクスポート
<a name="UsingWithRDS.IAMDBAuth.Troubleshooting.ErrorLogs"></a>

IAM DB 認証エラーログはデータベースホストに保存され、CloudWatch Logs アカウントでこれらのログをエクスポートできます。このページのログと修復方法を使用して、IAM DB 認証の問題をトラブルシューティングします。

コンソール、AWS CLI、および RDS API から CloudWatch Logs へのログエクスポートを有効にできます。コンソールの手順については、「[Amazon CloudWatch Logs へのデータベースログの発行](USER_LogAccess.Procedural.UploadtoCloudWatch.md)」を参照してください。

AWS CLI から DB インスタンスを作成するときに IAM DB 認証エラーログを CloudWatch Logs にエクスポートするには、次のコマンドを使用します。

```
aws rds create-db-instance --db-instance-identifier mydbinstance \
--region us-east-1 \
--db-instance-class db.t3.large \
--allocated-storage 50 \
--engine postgres \
--engine-version 16 \
--port 5432 \
--master-username master \
--master-user-password password \
--publicly-accessible \
--enable-iam-database-authentication \
--enable-cloudwatch-logs-exports=iam-db-auth-error
```

AWS CLI から DB インスタンスを変更するときに IAM DB 認証エラーログを CloudWatch Logs にエクスポートするには、次のコマンドを使用します。

```
aws rds modify-db-instance --db-instance-identifier mydbinstance \
--region us-east-1 \
--cloudwatch-logs-export-configuration '{"EnableLogTypes":["iam-db-auth-error"]}'
```

DB インスタンスが IAM DB 認証ログを CloudWatch Logs にエクスポートしているかどうかを確認するには、`describe-db-instances` コマンドの出力で `EnabledCloudwatchLogsExports` パラメータが `iam-db-auth-error` に設定されているかどうかを確認します。

```
aws rds describe-db-instances --region us-east-1 --db-instance-identifier mydbinstance
            ...
            
             "EnabledCloudwatchLogsExports": [
                "iam-db-auth-error"
            ],
            ...
```

## IAM DB 認証 CloudWatch メトリクス
<a name="UsingWithRDS.IAMDBAuth.Troubleshooting.CWMetrics"></a>

Amazon RDS は、IAM DB 認証に関するほぼリアルタイムのメトリクスを Amazon CloudWatch アカウントに配信します。次の表に、CloudWatch で使用可能な IAM DB 認証メトリクスを示します。


| メトリクス | 説明 | 
| --- | --- | 
|  `IamDbAuthConnectionRequests`  |  IAM DB 認証で行われた接続リクエストの合計数。  | 
|  `IamDbAuthConnectionSuccess`  |  成功した IAM DB 認証リクエストの合計数。  | 
|  `IamDbAuthConnectionFailure`  |  失敗した IAM DB 認証リクエストの合計数。  | 
|  `IamDbAuthConnectionFailureInvalidToken`  | トークンが無効であるために失敗した IAM DB 認証リクエストの合計数。 | 
|  `IamDbAuthConnectionFailureInsufficientPermissions`  |  ポリシーまたはアクセス許可が正しくないために失敗した IAM DB 認証リクエストの合計数。  | 
|  `IamDbAuthConnectionFailureThrottling`  |  IAM DB 認証スロットリングにより失敗した IAM DB 認証リクエストの合計数。  | 
|  `IamDbAuthConnectionFailureServerError`  |  IAM DB 認証機能の内部サーバーエラーにより失敗した IAM DB 認証リクエストの合計数。  | 

## 一般的な の問題と解決策
<a name="UsingWithRDS.IAMDBAuth.Troubleshooting.IssuesSolutions"></a>

 IAM DB 認証の使用時に、次の問題が発生することがあります。問題を解決するには、表の修復ステップを使用します。


| エラー | メトリクス | 原因 | ソリューション | 
| --- | --- | --- | --- | 
|  `[ERROR] Failed to authenticate the connection request for user db_user because the provided token is malformed or otherwise invalid. (Status Code: 400, Error Code: InvalidToken)`  |  `IamDbAuthConnectionFailure` `IamDbAuthConnectionFailureInvalidToken`  |  接続リクエストの IAM DB 認証トークンが有効な SigV4a トークンではないか、正しくフォーマットされていません。  |  アプリケーションでトークン生成戦略を確認します。場合によっては、トークンを有効なフォーマットで渡していることを確認してください。トークンを切り捨てる (または文字列形式が正しくない) と、トークンは無効になります。  | 
|  `[ERROR] Failed to authenticate the connection request for user db_user because the token age is longer than 15 minutes. (Status Code: 400, Error Code:ExpiredToken)`  |  `IamDbAuthConnectionFailure` `IamDbAuthConnectionFailureInvalidToken`  |  IAM DB 認証トークンの有効期限が切れています。トークンは 15 分間のみ有効です。  |  アプリケーションでトークンキャッシュやトークン再利用ロジックを確認します。15 分を超えたトークンは再利用しないでください。  | 
|  `[ERROR] Failed to authorize the connection request for user db_user because the IAM policy assumed by the caller 'arn:aws:sts::123456789012:assumed-role/ <RoleName>/ <RoleSession>' is not authorized to perform `rds-db:connect` on the DB instance. (Status Code: 403, Error Code:NotAuthorized)`  |  `IamDbAuthConnectionFailure` `IamDbAuthConnectionFailureInsufficientPermissions`  |  このエラーの原因としては、以下が考えられます。 [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/AmazonRDS/latest/UserGuide/UsingWithRDS.IAMDBAuth.Troubleshooting.html)  |  アプリケーションで引き受ける IAM ロールおよび/またはポリシーを確認します。DB に接続するためのトークンを生成するには、同じポリシーを引き受けていることを確認してください。  | 
|  `[ERROR] Failed to authorize the connection request for user db_user due to IAM DB authentication throttling. (Status Code: 429, Error Code: ThrottlingException)`  |  `IamDbAuthConnectionFailure` `IamDbAuthConnectionFailureThrottling`  | 短時間に DB への接続リクエストが多すぎます。IAM DB 認証のスロットリング制限は、1 秒あたり 200 接続です。 |  IAM 認証を使用して新しい接続を確立する速度を下げます。アプリケーションで確立された接続を再利用するには、RDS Proxy を使用して接続プールを実装することを検討してください。  | 
|  `[ERROR] Failed to authorize the connection request for user db_user due to an internal IAM DB authentication error. (Status Code: 500, Error Code: InternalError)`  |  `IamDbAuthConnectionFailure` `IamDbAuthConnectionFailureThrottling` |  IAM DB 認証で DB 接続の承認中に内部エラーが発生しました。  |  https://aws.amazon.com/premiumsupport/ に連絡して問題を調査してください。  |