# MariaDB, MySQL 및 PostgreSQL IAM 데이터베이스 인증
AWS Identity and Access Management(IAM) 데이터베이스 인증을 사용하여 DB 인스턴스에 인증할 수 있습니다. IAM 데이터베이스 인증은 MariaDB, MySQL, PostgreSQL과 함께 작동합니다. 이러한 인증 방식은 DB 인스턴스에 연결할 때 암호를 사용할 필요 없습니다. 대신에 인증 토큰을 사용합니다.
*인증 토큰*이란 요청이 있을 때 Amazon RDS가 생성하는 고유 문자열입니다. 인증 토큰은 AWS 서명 버전 4를 통해 생성됩니다. 각 토큰의 수명은 15분입니다. 인증을 외부에서 IAM을 사용해 관리하기 때문에 사용자 자격 증명을 데이터베이스에 저장할 필요도 없습니다. 또한 표준 데이터베이스 인증 방식도 사용 가능합니다. 토큰은 인증에만 사용되며 설정된 후에는 세션에 영향을 주지 않습니다.
IAM 데이터베이스 인증은 다음과 같은 이점이 있습니다.
+ 데이터베이스를 오가는 네트워크 트래픽은 SSL(Secure Sockets Layer) 또는 TLS(Transport Layer Security)를 통해 암호화됩니다. Amazon RDS에서 SSL/TLS를 사용하는 방법에 대한 자세한 내용은 [SSL/TLS를 사용하여 DB 인스턴스 또는 클러스터 에 대한 연결 암호화](UsingWithRDS.SSL.md) 섹션을 참조하십시오.
+ 데이터베이스 리소스에 대한 액세스는 DB 인스턴스에서 개별적으로 관리할 필요 없이 IAM을 통해 중앙에서 관리할 수 있습니다.
+ Amazon EC2에서 실행되는 애플리케이션의 경우, 암호가 아닌 EC2 인스턴스용 프로파일 자격 증명을 사용해 데이터베이스에 액세스하기 때문에 보안을 더욱 강화하는 효과가 있습니다.
일반적으로 애플리케이션에서 초당 200개 미만의 연결을 생성하고 애플리케이션 코드에서 사용자 이름과 암호를 직접 관리하지 않으려는 경우 IAM 데이터베이스 인증을 사용하는 것이 좋습니다.
Amazon Web Services(AWS) JDBC 드라이버는 IAM 데이터베이스 인증을 지원합니다. 자세한 내용은 [Amazon Web Services (AWS) JDBC Driver GitHub repository](https://github.com/aws/aws-advanced-jdbc-wrapper)에서 [AWS IAM Authentication Plugin](https://github.com/aws/aws-advanced-jdbc-wrapper/blob/main/docs/using-the-jdbc-driver/using-plugins/UsingTheIamAuthenticationPlugin.md)을 참조하세요.
Amazon Web Services(AWS) Python 드라이버는 IAM 데이터베이스 인증을 지원합니다. 자세한 내용은 [Amazon Web Services (AWS) Python Driver GitHub repository](https://github.com/aws/aws-advanced-python-wrapper)에서 [AWS IAM Authentication Plugin](https://github.com/aws/aws-advanced-python-wrapper/blob/main/docs/using-the-python-driver/using-plugins/UsingTheIamAuthenticationPlugin.md)을 참조하세요.
다음 주제를 탐색하여 DB 인증을 위한 IAM을 설정하는 프로세스를 알아봅니다.
+ [IAM 데이터베이스 인증의 활성화 및 비활성화](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [IAM 데이터베이스 액세스를 위한 IAM 정책 생성 및 사용](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [IAM 인증을 사용하여 데이터베이스 계정 생성](UsingWithRDS.IAMDBAuth.DBAccounts.md)
+ [IAM 인증을 사용하여 DB 인스턴스에 연결](UsingWithRDS.IAMDBAuth.Connecting.md)
## 리전 및 버전 사용 가능 여부
기능 가용성 및 해당 지원은 각 데이터베이스 엔진의 특정 버전에 따라 다릅니다. Amazon RDS 및 IAM 데이터베이스 인증을 통한 엔진, 버전 및 리전 가용성에 대한 자세한 내용은 [Amazon RDS에서 IAM 데이터베이스 인증을 지원하는 리전 및 DB 엔진](Concepts.RDS_Fea_Regions_DB-eng.Feature.IamDatabaseAuthentication.md) 섹션을 참조하세요.
## CLI 및 SDK 지원
[AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/rds/generate-db-auth-token.html) 및 다음 언어별 AWS SDK에서 IAM 데이터베이스 인증을 사용할 수 있습니다.
+ [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 데이터베이스 인증 방식의 제한 사항
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 권한 부여에는 데이터베이스 인스턴스의 컴퓨팅 리소스가 필요합니다. 신뢰할 수 있는 연결을 위해 데이터베이스에 300MiB 및 1,000MiB 사이의 추가 메모리가 있어야 합니다. 워크로드에 필요한 메모리를 보려면 IAM DB 인증을 사용하기 전과 후에 확장 모니터링 프로세스 목록에서 RDS 프로세스에 대한 RES 열을 비교합니다. [RDS 콘솔에서 OS 지표 보기](USER_Monitoring.OS.Viewing.md)을(를) 참조하세요.
버스트 가능 클래스 인스턴스를 사용하는 경우 버퍼 및 캐시와 같은 다른 파라미터에서 사용되는 메모리를 동일한 양만큼 줄여 메모리가 부족하지 않도록 합니다.
+ 엔진에 상관없이 RDS on Outposts에서는 IAM DB 인증이 지원되지 않습니다.
## IAM 데이터베이스 인증에 대한 권장 사항
IAM 데이터베이스 인증을 사용할 경우 다음을 따르는 게 좋습니다.
+ 애플리케이션에 초당 200개 미만의 새 IAM 데이터베이스 인증 연결이 필요한 경우에는 IAM 데이터베이스 인증 방식을 사용합니다.
Amazon RDS에서 작동하는 데이터베이스 엔진은 초당 인증 횟수에 제한이 없습니다. 하지만 IAM 데이터베이스 인증 방식을 사용할 때는 애플리케이션이 인증 토큰을 생성해야 합니다. 이렇게 생성된 토큰은 애플리케이션이 DB 인스턴스에 연결하는 데 사용됩니다. 초당 허용되는 새 연결의 최대 수를 초과하면 IAM 데이터베이스 인증에 오버헤드가 추가로 발생하여 연결 병목 현상이 발생할 수 있습니다.
지속적인 연결 생성을 줄이려면 애플리케이션에서 연결 풀링을 사용하는 것이 좋습니다. 이렇게 하면 IAM DB 인증으로 인한 오버헤드를 줄이고 애플리케이션이 기존 연결을 재사용할 수 있습니다. 또는 이러한 사용 사례에 RDS 프록시를 사용하는 것도 좋습니다. RDS 프록시에는 추가 비용이 부과됩니다. [RDS 프록시 요금](https://aws.amazon.com/rds/proxy/pricing/)을 참조하세요.
+ IAM 데이터베이스 인증 토큰의 크기는 IAM 태그 수, IAM 서비스 정책, ARN 길이, 기타 IAM 및 데이터베이스 속성 등 여러 요소에 따라 달라집니다. 이 토큰의 최소 크기는 일반적으로 약 1KB지만 더 클 수도 있습니다. 이 토큰은 IAM 인증을 사용하는 데이터베이스에 대한 연결 문자열에서 암호로 사용되므로 데이터베이스 드라이버(예: ODBC) 및/또는 어떤 도구도 크기로 인해 이 토큰을 제한하거나 자르지 않도록 해야 합니다. 토큰이 잘리면 데이터베이스와 IAM에서 수행하는 인증 검증이 실패합니다.
+ IAM 데이터베이스 인증 토큰을 생성할 때 임시 보안 인증 정보를 사용하는 경우, IAM 데이터베이스 인증 토큰을 사용하여 연결을 요청할 때 임시 보안 인증 정보가 여전히 유효해야 합니다.
## 지원되지 않는 AWS 전역 조건 컨텍스트 키
IAM 데이터베이스 인증은 다음과 같은 AWS 전역 조건 컨텍스트 키의 하위 집합을 지원하지 않습니다.
+ `aws:Referer`
+ `aws:SourceIp`
+ `aws:SourceVpc`
+ `aws:SourceVpce`
+ `aws:UserAgent`
+ `aws:VpcSourceIp`
자세한 내용은 *IAM 사용 설명서*의 [AWS 글로벌 조건 컨텍스트 키](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html)를 참조하세요.
# IAM 데이터베이스 인증의 활성화 및 비활성화
DB 인스턴스에서는 기본적으로 IAM 데이터베이스 인증이 비활성화되어 있습니다. IAM 데이터베이스 인증은 AWS Management Console, AWS CLI 또는 API를 사용하여 활성화하거나 비활성화할 수 있습니다.
다음 작업 중 하나를 수행할 때 IAM 데이터베이스 인증을 활성화할 수 있습니다.
+ IAM 데이터베이스 인증이 활성화된 새 DB 인스턴스를 생성하려면 [Amazon RDS DB 인스턴스 생성](USER_CreateDBInstance.md) 섹션을 참조하세요.
+ IAM 데이터베이스 인증을 사용하도록 DB 인스턴스를 수정하려면 [Amazon RDS DB 인스턴스 수정](Overview.DBInstance.Modifying.md) 섹션을 참조하세요.
+ IAM 데이터베이스 인증이 활성화된 스냅샷에서 DB 인스턴스를 복원하려면 [DB 인스턴스 복원](USER_RestoreFromSnapshot.md) 섹션을 참조하세요.
+ IAM 데이터베이스 인증이 사용 설정된 시점으로 DB 인스턴스를 복원하려면 [Amazon RDS에서 DB 인스턴스를 지정된 시간으로 복원](USER_PIT.md) 섹션을 참조하세요.
## 콘솔
각 생성 또는 수정 워크플로에는 IAM 데이터베이스 인증을 활성화하거나 비활성화할 수 있는 **데이터베이스 인증(Database authentication)** 섹션이 있습니다. 이 섹션에서 **암호 및 IAM 데이터베이스 인증(Password and IAM database authentication)**을 선택하여 IAM 데이터베이스 인증을 활성화합니다.
**기존 DB 인스턴스에서 IAM 데이터베이스 인증을 활성화하거나 비활성화하려면**
1. [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/)에서 Amazon RDS 콘솔을 엽니다.
1. 탐색 창에서 **데이터베이스**를 선택합니다.
1. 수정하려는 DB 인스턴스를 선택합니다.
**참고**
DB 인스턴스가 IAM 인증과 호환되는지 확인합니다. 호환성 요구 사항은 [리전 및 버전 사용 가능 여부](UsingWithRDS.IAMDBAuth.md#UsingWithRDS.IAMDBAuth.Availability) 섹션을 참조하십시오.
1. **수정**을 선택합니다.
1. **데이터베이스 인증** 섹션에서 **암호 및 IAM 데이터베이스 인증** 을 선택하여 IAM 데이터베이스 인증을 활성화합니다. **암호 인증** 또는 **암호 및 Kerberos 인증**을 선택하여 IAM 인증을 비활성화합니다.
1. 또한 CloudWatch Logs에 IAM DB 인증 로그 게시를 사용하도록 선택할 수 있습니다. **로그 내보내기**에서 **iam-db-auth-error 로그** 옵션을 선택합니다. CloudWatch Logs에 로그를 게시하면 스토리지가 사용되며 해당 스토리지에 대한 요금이 부과됩니다. 더 이상 필요하지 않은 CloudWatch Logs는 삭제해야 합니다.
1. [**Continue**]를 선택합니다.
1. 변경 사항을 즉시 적용하려면 **수정 예약(Scheduling of modifications)** 섹션에서 **즉시(Immediately)**를 선택합니다.
1. **DB 인스턴스 수정** 을 선택합니다.
## AWS CLI
AWS CLI를 사용하여 새로운 DB 인스턴스를 IAM 인증 방식으로 생성하려면 [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
API를 사용하여 새로운 DB 인스턴스를 IAM 인증 방식으로 생성하려면 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 정책 생성 및 사용
사용자 또는 역할이 DB 인스턴스에 연결할 수 있도록 허용하려면 IAM 정책을 생성해야 합니다. 그런 다음 정책을 권한 세트 또는 역할에 연결합니다.
**참고**
IAM 정책에 대한 자세한 정보는 [Amazon RDS의 자격 증명 및 액세스 관리](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 작업 접두사와 혼동하지 마십시오. `rds-db:` 접두사와 `rds-db:connect` 작업은 IAM 데이터베이스 인증 전용입니다. 다른 컨텍스트에서는 유효하지 않습니다.
위의 예제 정책에는 다음 요소와 함께 단일 문이 포함되어 있습니다.
+ `Effect` – `Allow`를 지정하여 DB 인스턴스에 대한 액세스를 부여합니다. 액세스를 명시적으로 허용하지 않으면 액세스가 기본적으로 거부됩니다.
+ `Action` – `rds-db:connect`를 지정하여 DB 인스턴스에 대한 연결을 허용합니다.
+ `Resource` – 하나의 DB 인스턴스의 한 데이터베이스 계정을 기술하는 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용 AWS Management Console에서 인스턴스 리소스 ID를 찾으려면 DB 인스턴스를 선택하여 세부 정보를 확인하세요. 그런 다음 **구성** 탭을 선택합니다. 그러면 **리소스 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 프록시를 통해 데이터베이스에 연결하는 경우, 프록시 리소스 ID(예: `prx-ABCDEFGHIJKL01234`)를 지정합니다. RDS 프록시에서 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"
]
}
]
}
```
------
다음 정책에서는 "\$1" 문자를 사용하여 특정 AWS 계정과 AWS 리전의 모든 DB 인스턴스 및 데이터베이스 계정을 일치시킵니다.
------
#### [ 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 인스턴스에게만 액세스 권한이 부여됩니다.
------
#### [ 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 정책 연결
데이터베이스 인증을 위한 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 인증을 사용하여 데이터베이스 계정 생성
IAM 데이터베이스 인증 방식에서는 데이터베이스 암호를 사용자 계정에 할당할 필요 없습니다. 데이터베이스 계정에 매핑되어 있는 사용자를 제거할 경우에는 `DROP USER` 문으로 데이터베이스 계정도 제거해야 합니다.
**참고**
IAM 인증에 사용되는 사용자 이름은 데이터베이스에 있는 사용자 이름과 대소문자가 일치해야 합니다.
**Topics**
+ [
## MariaDB 및 MySQL에서 IAM 인증 사용
](#UsingWithRDS.IAMDBAuth.DBAccounts.MySQL)
+ [
## PostgreSQL에서 IAM 인증 사용
](#UsingWithRDS.IAMDBAuth.DBAccounts.PostgreSQL)
## MariaDB 및 MySQL에서 IAM 인증 사용
MariaDB 및 MySQL에서는 AWS에서 제공하는 플러그인인 `AWSAuthenticationPlugin`에서 인증을 처리합니다. 이 플러그인은 IAM과 원활하게 연동되어 사용자를 인증합니다. 마스터 사용자 또는 사용자를 생성하고 권한을 부여할 수 있는 다른 사용자로 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) 섹션을 참조하세요.
**참고**
다음과 같은 메시지가 표시되면 현재 DB 인스턴스에서 AWS 제공 플러그인을 사용할 수 없는 것입니다.
`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 인증 사용
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 인스턴스에 연결
IAM 데이터베이스 인증 방식에서는 DB 인스턴스 에 연결할 때 인증 토큰을 사용합니다. *인증 토큰*이란 암호 대신 사용하는 문자열을 말합니다. 인증 토큰은 생성 후 15분 동안만 유효하며 이 시간이 지나면 만료됩니다. 만료된 토큰을 사용하여 연결하려고 하면 연결 요청이 거부됩니다.
모든 인증 토큰은 AWS 서명 버전 4를 사용하여 유효한 서명이 있어야 합니다. (자세한 내용은 *AWS 일반 참조*의 [서명 버전 4 서명 프로세스](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html)를 참조하세요.) AWS SDK for Java 또는 AWS SDK for Python (Boto3)와 같은 AWS CLI 및 AWS SDK는 사용자가 생성한 각 토큰에 자동으로 서명할 수 있습니다.
AWS Lambda와 같은 AWS 서비스에서 Amazon RDS에 연결할 때 인증 토큰을 사용할 수 있습니다. 토큰을 사용하면 코드에 암호를 넣지 않아도 됩니다. 그 밖에 AWS SDK를 사용하여 인증 토큰을 프로그래밍 방식으로 생성하고 프로그래밍 방식으로 서명하는 방법도 있습니다.
IAM 인증 토큰에 서명까지 마쳤으면 이제 Amazon RDS DB 인스턴스에 연결할 수 있습니다. 다음 섹션에서는 명령줄 도구 또는 AWS SDK(예: AWS SDK for Java 또는 AWS SDK for Python (Boto3))를 사용하여 연결하는 방법에 대해 알아보겠습니다.
자세한 내용은 다음 블로그 게시물을 참조하십시오.
+ [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/)
+ [Using IAM authentication to connect with pgAdmin Amazon Aurora PostgreSQL or 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/)
**사전 조건**
다음은 IAM 인증을 사용하여 DB 인스턴스에 연결하기 위한 사전 조건입니다.
+ [IAM 데이터베이스 인증의 활성화 및 비활성화](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [IAM 데이터베이스 액세스를 위한 IAM 정책 생성 및 사용](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [IAM 인증을 사용하여 데이터베이스 계정 생성](UsingWithRDS.IAMDBAuth.DBAccounts.md)
**Topics**
+ [
# AWS 드라이버와 함께 IAM 인증을 사용하여 DB 인스턴스에 연결
](IAMDBAuth.Connecting.Drivers.md)
+ [
# 명령줄에서 IAM 인증을 사용하여 DB 인스턴스에 연결: AWS CLI 및 mysql 클라이언트
](UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.md)
+ [
# 명령줄: AWS CLI 및 psql Client에서 IAM 인증을 사용하여 DB 인스턴스에 연결
](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)
# AWS 드라이버와 함께 IAM 인증을 사용하여 DB 인스턴스에 연결
더 빠른 전환 및 장애 조치 시간, AWS Secrets Manager, AWS Identity and Access Management(IAM) 및 페더레이션 ID를 사용한 인증을 지원하도록 설계된 AWS 드라이버 제품군입니다. AWS 드라이버는 DB 인스턴스 상태 모니터링과 인스턴스 토폴로지 파악을 통해 새 라이터를 결정합니다. 이 접근 방식은 전환 및 장애 조치 시간을 오픈 소스 드라이버의 경우 수십 초였던 것에 비해 10초 미만으로 단축합니다.
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 클라이언트
아래 설명과 같이 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 인증을 통한 SQL Workbench/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 인증 토크 생성
다음은 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 인스턴스에 연결
일반적인 연결 형식은 다음과 같습니다.
```
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 인증 토큰입니다.
인증 토큰은 수백 자의 문자로 구성됩니다. 그렇기 때문에 명령줄에서는 다루지 불편할 수도 있습니다. 이러한 문제를 해결하기 위해 토큰을 환경 변수로 저장한 후 연결할 때 이 변수를 사용하는 것도 한 가지 방법입니다. 다음은 이러한 문제 해결 방법을 설명한 예제입니다. 이 예에서 */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)을 참조하세요.
# 명령줄: AWS CLI 및 psql Client에서 IAM 인증을 사용하여 DB 인스턴스에 연결
아래 설명과 같이 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)
**참고**
IAM 인증을 통한 pgAdmin을 사용하여 데이터베이스에 연결하는 방법에 대한 자세한 내용은 블로그 게시물 [Using IAM authentication to connect with pgAdmin Amazon Aurora PostgreSQL or 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 인증 토크 생성
인증 토큰은 수백 자의 문자로 구성되므로 명령줄에서는 다루기 불편할 수 있습니다. 이러한 문제를 해결하기 위해 토큰을 환경 변수로 저장한 후 연결할 때 이 변수를 사용하는 것도 한 가지 방법입니다. 다음 예제는 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 인스턴스 에 연결
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 연결에서 SSL 인증서의 엔드포인트와 비교하여 DB 인스턴스 엔드포인트를 확인합니다.
+ `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 인스턴스에 연결
아래 설명과 같이 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](https://aws.amazon.com/sdk-for-net/)가 필요하며 이는 AWS 사이트에서 받을 수 있습니다. `AWSSDK.CORE` 및 `AWSSDK.RDS` 패키지가 필요합니다. DB 인스턴스에 연결하려면 DB 엔진용 .NET 데이터베이스 커넥터(예: MariaDB 또는 MySQL용 MySQL커넥터 또는 PostgreSQL용 Npgsql)를 사용합니다.
이 코드는 MariaDB 또는 MySQL DB 인스턴스에 연결됩니다. 필요하다면 다음 변수 값을 변경합니다.
+ `server` - 액세스할 DB 인스턴스의 엔드포인트입니다.
+ `user` – 액세스할 데이터베이스 계정입니다.
+ `database` – 액세스할 데이터베이스입니다.
+ `port` – DB 인스턴스에 연결할 때 사용할 포트 번호입니다.
+ `SslMode` – 사용할 SSL 모드입니다.
`SslMode=Required`을 사용하면 SSL 연결에서 SSL 인증서의 엔드포인트와 비교하여 DB 인스턴스 엔드포인트를 확인합니다.
+ `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 연결에서 SSL 인증서의 엔드포인트와 비교하여 DB 인스턴스 엔드포인트를 확인합니다.
+ `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 인스턴스에 연결
아래 설명과 같이 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](https://aws.amazon.com/sdk-for-go/)가 필요하며 이는 AWS 사이트에서 받을 수 있습니다.
필요하다면 다음 변수 값을 변경합니다.
+ `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를 사용하여 연결
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을 사용하여 연결
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 인스턴스에 연결
아래 설명과 같이 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)
Java 2.x용 SDK를 사용하는 방법에 대한 예제는 [Java 2.x용 SDK를 사용한 Amazon RDS 예제](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/java_rds_code_examples.html)를 참조하세요. 또한 AWS 고급 JDBC 래퍼를 사용할 수 있습니다. [AWS Advanced JDBC Wrapper documentation](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 인증 토크 생성
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 인증 토큰 수동 구성
Java에서 인증 토큰을 가장 쉽게 생성할 수 있는 방법은 `RdsIamAuthTokenGenerator`를 사용하는 것입니다. 이 클래스는 인증 토큰을 생성한 후 AWS 서명 버전 4를 사용해 서명까지 마칩니다. (자세한 내용은 *AWS 일반 참조*의 [서명 버전 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 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 인스턴스에 연결
다음은 인증 토큰을 생성하고, 이를 사용하여 MariaDB 또는 MySQL을 실행하는 인스턴스에 연결하는 방법을 보여주는 코드 예입니다.
이 코드 예제를 실행하려면 [AWS SDK for Java](https://aws.amazon.com/sdk-for-java/)가 필요하며 이는 AWS 사이트에서 받을 수 있습니다. 또한 다음이 필요합니다.
+ 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) 섹션을 참조하세요. SSL 인증서는 예제 실행 시 클래스 로더가 인증서를 찾을 수 있도록 이 Java 프로그램 파일과 동일한 디렉터리에 설치합니다.
다음은 [기본 자격 증명 공급자 체인](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 인스턴스에 연결
아래 설명과 같이 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)](https://aws.amazon.com/sdk-for-python/)가 필요하며 이는 AWS 사이트에서 받을 수 있습니다.
필요하다면 다음 변수 값을 변경합니다.
+ `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 색인](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 설명서](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 인증 문제 해결
여기에서는 몇 가지 일반적인 IAM DB 인증 문제에 대한 문제 해결 아이디어와 IAM DB 인증에 대한 CloudWatch 로그 관련 정보를 확인할 수 있습니다.
## IAM DB 인증 오류 로그를 CloudWatch Logs로 내보내기
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 지표
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 인증 요청의 총 개수입니다. |
## 일반적인 문제 및 해결 방법
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/ / ' 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/ko_kr/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 인증 스로틀링 한도는 초당 200개의 연결입니다. | IAM 인증으로 새 연결을 설정하는 속도를 줄입니다. 애플리케이션에서 설정된 연결을 재사용하려면 RDS 프록시를 사용하여 연결 풀링을 구현하는 것이 좋습니다. |
| `[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/를 통해 문의하시기 바랍니다. |