# Amazon RDS와 함께 AWS Lambda 사용
Lambda 함수를 Amazon RDS Proxy를 통해 Amazon Relational Database Service(RDS) 데이터베이스에 직접 연결할 수 있습니다. 간단한 시나리오에서는 직접 연결이 유용하며 프로덕션에서는 프록시를 사용하는 것이 좋습니다. 데이터베이스 프록시는 함수가 데이터베이스 연결을 소진하지 않고 높은 동시성 레벨에 도달할 수 있도록 하는 공유 데이터베이스 연결 풀을 관리합니다.
짧게 데이터베이스를 연결하거나 다수의 데이터베이스 연결을 열고 닫는 Lambda 함수에는 Amazon RDS Proxy를 사용하는 것이 좋습니다. 자세한 내용은 Amazon Relational Database Service 개발자 안내서의 [Lambda 함수와 DB 인스턴스 자동 연결](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/lambda-rds-connect.html)을 참조하세요.
**작은 정보**
Lambda 함수를 Amazon RDS 데이터베이스에 빠르게 연결하려면 콘솔 내 안내 마법사를 사용할 수 있습니다. 마법사에서 다음을 수행합니다.
Lambda 콘솔의 [함수 페이지](https://console.aws.amazon.com/lambda/home#/functions)를 엽니다.
데이터베이스를 연결할 함수를 선택합니다.
**구성** 탭에서 **RDS 데이터베이스**를 선택합니다.
**RDS 데이터베이스에 연결**을 선택합니다.
함수를 데이터베이스에 연결한 후 **프록시 추가**를 선택하여 프록시를 생성할 수 있습니다.
## RDS 리소스와 함께 작동하도록 함수 구성
Lambda 콘솔에서는 Amazon RDS 데이터베이스 인스턴스와 프록시 리소스를 프로비저닝하고 구성할 수 있습니다. **구성** 탭 아래의 **RDS 데이터베이스**로 이동하여 이 작업을 수행할 수 있습니다. 또는 Amazon RDS 콘솔에서 Lambda 함수에 대한 연결을 생성하고 구성할 수도 있습니다. Lambda와 함께 사용하도록 RDS 데이터베이스 인스턴스를 구성할 때는 다음 기준에 유의하세요.
+ 데이터베이스에 연결하려면 데이터베이스를 실행하는 동일한 Amazon VPC에 함수가 있어야 합니다.
+ MySQL, MariaDB, PostgreSQL 또는 Microsoft SQL Server 엔진과 함께 Amazon RDS 데이터베이스를 사용할 수 있습니다.
+ MySQL 또는 PostgreSQL 엔진과 함께 Aurora DB 클러스터를 사용할 수도 있습니다.
+ 데이터베이스 인증을 위해 Secrets Manager 보안 암호를 제공해야 합니다.
+ IAM 역할은 보안 암호를 사용할 권한을 제공해야 하며, 신뢰 정책에서는 Amazon RDS가 역할을 수임하도록 허용해야 합니다.
+ 콘솔을 사용하여 Amazon RDS 리소스를 구성하고 이를 함수에 연결하는 IAM 위탁자에는 다음 권한이 있어야 합니다.
### 권한 정책 예
**참고**
데이터베이스 연결 풀을 관리하기 위해 Amazon RDS Proxy를 구성하는 경우에만 Amazon RDS Proxy 권한이 필요합니다.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ec2:CreateSecurityGroup",
"ec2:DescribeSecurityGroups",
"ec2:DescribeSubnets",
"ec2:DescribeVpcs",
"ec2:AuthorizeSecurityGroupIngress",
"ec2:AuthorizeSecurityGroupEgress",
"ec2:RevokeSecurityGroupEgress",
"ec2:CreateNetworkInterface",
"ec2:DeleteNetworkInterface",
"ec2:DescribeNetworkInterfaces"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"rds-db:connect",
"rds:CreateDBProxy",
"rds:CreateDBInstance",
"rds:CreateDBSubnetGroup",
"rds:DescribeDBClusters",
"rds:DescribeDBInstances",
"rds:DescribeDBSubnetGroups",
"rds:DescribeDBProxies",
"rds:DescribeDBProxyTargets",
"rds:DescribeDBProxyTargetGroups",
"rds:RegisterDBProxyTargets",
"rds:ModifyDBInstance",
"rds:ModifyDBProxy"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"lambda:CreateFunction",
"lambda:ListFunctions",
"lambda:UpdateFunctionConfiguration"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"iam:AttachRolePolicy",
"iam:CreateRole",
"iam:CreatePolicy"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"secretsmanager:GetResourcePolicy",
"secretsmanager:GetSecretValue",
"secretsmanager:DescribeSecret",
"secretsmanager:ListSecretVersionIds",
"secretsmanager:CreateSecret"
],
"Resource": "*"
}
]
}
```
------
Amazon RDS는 데이터베이스 인스턴스 크기를 기준으로 프록시에 시간당 요금을 부과합니다. 자세한 내용은 [RDS 프록시 요금](https://aws.amazon.com/rds/proxy/pricing/)을 참조하세요. 일반적인 프록시 연결에 대한 자세한 내용은 Amazon RDS 사용 설명서에서 [Amazon RDS Proxy 사용](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/rds-proxy.html)을 참조하세요.
### Amazon RDS 연결에 대한 SSL/TLS 요구 사항
Amazon RDS 데이터베이스 인스턴스에 대한 보안 SSL/TLS 연결을 설정하려면 Lambda 함수에서 신뢰할 수 있는 인증서를 사용하여 데이터베이스 서버의 ID를 확인해야 합니다. Lambda는 배포 패키지 유형에 따라 이러한 인증서를 다르게 처리합니다.
+ [.zip 파일 아카이브](configuration-function-zip.md): 인증서 처리는 런타임에 따라 다릅니다.
+ **Node.js 18 이하**: Lambda에 CA 인증서 및 RDS 인증서가 자동으로 포함됩니다.
+ **Node.js 20 이상**: Lambda는 더 이상 기본적으로 추가 CA 인증서를 로딩하지 않습니다. `NODE_EXTRA_CA_CERTS` 환경 변수를 `/var/runtime/ca-cert.pem`로 설정합니다.
새 AWS 리전에 대한 Amazon RDS 인증서가 Lambda 관리형 런타임에 추가되는 데 최대 4주까지 소요될 수 있습니다.
+ [컨테이너 이미지](images-create.md): AWS 기본 이미지에는 CA 인증서만 포함됩니다. 함수가 Amazon RDS 데이터베이스 인스턴스에 연결하는 경우 컨테이너 이미지에 적절한 인증서를 포함해야 합니다. Dockerfile에서 [데이터베이스를 호스팅하는 AWS 리전에 해당하는 인증서 번들](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/UsingWithRDS.SSL.html#UsingWithRDS.SSL.CertificatesDownload)을 다운로드하세요. 예제:
```
RUN curl https://truststore.pki.rds.amazonaws.com/us-east-1/us-east-1-bundle.pem -o /us-east-1-bundle.pem
```
이 명령은 Amazon RDS 인증서 번들을 다운로드하여 컨테이너 루트 디렉터리의 절대 경로 `/us-east-1-bundle.pem`에 저장합니다. 함수 코드에서 데이터베이스 연결을 구성할 때 이 정확한 경로를 참조해야 합니다. 예제:
------
#### [ Node.js ]
Node.js 데이터베이스 클라이언트는 인증서 파일의 경로뿐만 아니라 메모리에 실제 인증서 내용이 필요하기 때문에 `readFileSync` 함수가 필요합니다. `readFileSync`가 없으면 클라이언트가 경로 문자열을 인증서 내용으로 해석하여 ‘인증서 체인에서 자체 서명된 인증서’ 오류가 발생합니다.
**Example OCI 함수에 대한 Node.js 연결 구성**
```
import { readFileSync } from 'fs';
// ...
let connectionConfig = {
host: process.env.ProxyHostName,
user: process.env.DBUserName,
password: token,
database: process.env.DBName,
ssl: {
ca: readFileSync('/us-east-1-bundle.pem') // Load RDS certificate content from file into memory
}
};
```
------
#### [ Python ]
**Example OCI 함수에 대한 Python 연결 구성**
```
connection = pymysql.connect(
host=proxy_host_name,
user=db_username,
password=token,
db=db_name,
port=port,
ssl={'ca': '/us-east-1-bundle.pem'} #Path to the certificate in container
)
```
------
#### [ Java ]
JDBC 연결을 사용하는 Java 함수의 경우 연결 문자열에 다음이 포함되어야 합니다.
+ `useSSL=true`
+ `requireSSL=true`
+ 컨테이너 이미지에서 Amazon RDS 인증서의 위치를 가리키는 `sslCA` 파라미터
**Example OCI 함수에 대한 Java 연결 문자열**
```
// Define connection string
String connectionString = String.format("jdbc:mysql://%s:%s/%s?useSSL=true&requireSSL=true&sslCA=/us-east-1-bundle.pem", // Path to the certificate in container
System.getenv("ProxyHostName"),
System.getenv("Port"),
System.getenv("DBName"));
```
------
#### [ .NET ]
**Example OCI 함수의 MySQL 연결에 대한 .NET 연결 문자열**
```
/// Build the Connection String with the Token
string connectionString = $"Server={Environment.GetEnvironmentVariable("RDS_ENDPOINT")};" +
$"Port={Environment.GetEnvironmentVariable("RDS_PORT")};" +
$"Uid={Environment.GetEnvironmentVariable("RDS_USERNAME")};" +
$"Pwd={authToken};" +
"SslMode=Required;" +
"SslCa=/us-east-1-bundle.pem"; // Path to the certificate in container
```
------
#### [ Go ]
MySQL 연결을 사용하는 Go 함수의 경우 Amazon RDS 인증서를 인증서 풀에 로드하고 MySQL 드라이버에 등록합니다. 그런 다음 연결 문자열은 `tls` 파라미터를 사용하여 이 구성을 참조해야 합니다.
**Example OCI 함수의 MySQL 연결에 대한 Go 코드**
```
import (
"crypto/tls"
"crypto/x509"
"os"
"github.com/go-sql-driver/mysql"
)
...
// Create certificate pool and register TLS config
rootCertPool := x509.NewCertPool()
pem, err := os.ReadFile("/us-east-1-bundle.pem") // Path to the certificate in container
if err != nil {
panic("failed to read certificate file: " + err.Error())
}
if ok := rootCertPool.AppendCertsFromPEM(pem); !ok {
panic("failed to append PEM")
}
mysql.RegisterTLSConfig("custom", &tls.Config{
RootCAs: rootCertPool,
})
dsn := fmt.Sprintf("%s:%s@tcp(%s)/%s?allowCleartextPasswords=true&tls=custom",
dbUser, authenticationToken, dbEndpoint, dbName,
)
```
------
#### [ Ruby ]
**Example OCI 함수에 대한 Ruby 연결 구성**
```
conn = Mysql2::Client.new(
host: endpoint,
username: user,
password: token,
port: port,
database: db_name,
sslca: '/us-east-1-bundle.pem', # Path to the certificate in container
sslverify: true
)
```
------
## Lambda 함수를 사용하여 Amazon RDS 데이터베이스에 연결
다음 코드 예제는 Amazon RDS 데이터베이스에 연결하는 Lambda 함수를 구현하는 방법을 보여줍니다. 이 함수는 간단한 데이터베이스 요청을 하고 결과를 반환합니다.
**참고**
이 코드 예제는 [.zip 배포 패키지](configuration-function-zip.md)에만 유효합니다. [컨테이너 이미지를](images-create.md) 사용하여 함수를 배포하는 경우 [이전 섹션](#oci-certificate)에 설명된 대로 함수 코드에 Amazon RDS 인증서 파일을 지정해야 합니다.
------
#### [ .NET ]
**SDK for .NET**
GitHub에 더 많은 내용이 있습니다. [서버리스 예제](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-connect-rds-iam) 리포지토리에서 전체 예제를 찾아보고 설정 및 실행 방법을 알아봅니다.
.NET을 사용하여 Lambda 함수에서 Amazon RDS 데이터베이스에 연결
```
using System.Data;
using System.Text.Json;
using Amazon.Lambda.APIGatewayEvents;
using Amazon.Lambda.Core;
using MySql.Data.MySqlClient;
// Assembly attribute to enable the Lambda function's JSON input to be converted into a .NET class.
[assembly: LambdaSerializer(typeof(Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer))]
namespace aws_rds;
public class InputModel
{
public string key1 { get; set; }
public string key2 { get; set; }
}
public class Function
{
///
// Handles the Lambda function execution for connecting to RDS using IAM authentication.
///
/// The input event data passed to the Lambda function
/// The Lambda execution context that provides runtime information
/// A response object containing the execution result
public async Task FunctionHandler(APIGatewayProxyRequest request, ILambdaContext context)
{
// Sample Input: {"body": "{\"key1\":\"20\", \"key2\":\"25\"}"}
var input = JsonSerializer.Deserialize(request.Body);
/// Obtain authentication token
var authToken = RDSAuthTokenGenerator.GenerateAuthToken(
Environment.GetEnvironmentVariable("RDS_ENDPOINT"),
Convert.ToInt32(Environment.GetEnvironmentVariable("RDS_PORT")),
Environment.GetEnvironmentVariable("RDS_USERNAME")
);
/// Build the Connection String with the Token
string connectionString = $"Server={Environment.GetEnvironmentVariable("RDS_ENDPOINT")};" +
$"Port={Environment.GetEnvironmentVariable("RDS_PORT")};" +
$"Uid={Environment.GetEnvironmentVariable("RDS_USERNAME")};" +
$"Pwd={authToken};";
try
{
await using var connection = new MySqlConnection(connectionString);
await connection.OpenAsync();
const string sql = "SELECT @param1 + @param2 AS Sum";
await using var command = new MySqlCommand(sql, connection);
command.Parameters.AddWithValue("@param1", int.Parse(input.key1 ?? "0"));
command.Parameters.AddWithValue("@param2", int.Parse(input.key2 ?? "0"));
await using var reader = await command.ExecuteReaderAsync();
if (await reader.ReadAsync())
{
int result = reader.GetInt32("Sum");
//Sample Response: {"statusCode":200,"body":"{\"message\":\"The sum is: 45\"}","isBase64Encoded":false}
return new APIGatewayProxyResponse
{
StatusCode = 200,
Body = JsonSerializer.Serialize(new { message = $"The sum is: {result}" })
};
}
}
catch (Exception ex)
{
Console.WriteLine($"Error: {ex.Message}");
}
return new APIGatewayProxyResponse
{
StatusCode = 500,
Body = JsonSerializer.Serialize(new { error = "Internal server error" })
};
}
}
```
------
#### [ Go ]
**SDK for Go V2**
GitHub에 더 많은 내용이 있습니다. [서버리스 예제](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-connect-rds-iam) 리포지토리에서 전체 예제를 찾아보고 설정 및 실행 방법을 알아봅니다.
Go를 사용하여 Lambda 함수에서 Amazon RDS 데이터베이스에 연결
```
/*
Golang v2 code here.
*/
package main
import (
"context"
"database/sql"
"encoding/json"
"fmt"
"os"
"github.com/aws/aws-lambda-go/lambda"
"github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/aws-sdk-go-v2/feature/rds/auth"
_ "github.com/go-sql-driver/mysql"
)
type MyEvent struct {
Name string `json:"name"`
}
func HandleRequest(event *MyEvent) (map[string]interface{}, error) {
var dbName string = os.Getenv("DatabaseName")
var dbUser string = os.Getenv("DatabaseUser")
var dbHost string = os.Getenv("DBHost") // Add hostname without https
var dbPort int = os.Getenv("Port") // Add port number
var dbEndpoint string = fmt.Sprintf("%s:%d", dbHost, dbPort)
var region string = os.Getenv("AWS_REGION")
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)
}
defer db.Close()
var sum int
err = db.QueryRow("SELECT ?+? AS sum", 3, 2).Scan(&sum)
if err != nil {
panic(err)
}
s := fmt.Sprint(sum)
message := fmt.Sprintf("The selected sum is: %s", s)
messageBytes, err := json.Marshal(message)
if err != nil {
return nil, err
}
messageString := string(messageBytes)
return map[string]interface{}{
"statusCode": 200,
"headers": map[string]string{"Content-Type": "application/json"},
"body": messageString,
}, nil
}
func main() {
lambda.Start(HandleRequest)
}
```
------
#### [ Java ]
**SDK for Java 2.x**
GitHub에 더 많은 내용이 있습니다. [서버리스 예제](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-connect-rds-iam) 리포지토리에서 전체 예제를 찾아보고 설정 및 실행 방법을 알아봅니다.
Java를 사용하여 Lambda 함수에서 Amazon RDS 데이터베이스에 연결
```
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import com.amazonaws.services.lambda.runtime.events.APIGatewayProxyRequestEvent;
import com.amazonaws.services.lambda.runtime.events.APIGatewayProxyResponseEvent;
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.rdsdata.RdsDataClient;
import software.amazon.awssdk.services.rdsdata.model.ExecuteStatementRequest;
import software.amazon.awssdk.services.rdsdata.model.ExecuteStatementResponse;
import software.amazon.awssdk.services.rdsdata.model.Field;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
public class RdsLambdaHandler implements RequestHandler {
@Override
public APIGatewayProxyResponseEvent handleRequest(APIGatewayProxyRequestEvent event, Context context) {
APIGatewayProxyResponseEvent response = new APIGatewayProxyResponseEvent();
try {
// Obtain auth token
String token = createAuthToken();
// Define connection configuration
String connectionString = String.format("jdbc:mysql://%s:%s/%s?useSSL=true&requireSSL=true",
System.getenv("ProxyHostName"),
System.getenv("Port"),
System.getenv("DBName"));
// Establish a connection to the database
try (Connection connection = DriverManager.getConnection(connectionString, System.getenv("DBUserName"), token);
PreparedStatement statement = connection.prepareStatement("SELECT ? + ? AS sum")) {
statement.setInt(1, 3);
statement.setInt(2, 2);
try (ResultSet resultSet = statement.executeQuery()) {
if (resultSet.next()) {
int sum = resultSet.getInt("sum");
response.setStatusCode(200);
response.setBody("The selected sum is: " + sum);
}
}
}
} catch (Exception e) {
response.setStatusCode(500);
response.setBody("Error: " + e.getMessage());
}
return response;
}
private String createAuthToken() {
// Create RDS Data Service client
RdsDataClient rdsDataClient = RdsDataClient.builder()
.region(Region.of(System.getenv("AWS_REGION")))
.credentialsProvider(DefaultCredentialsProvider.create())
.build();
// Define authentication request
ExecuteStatementRequest request = ExecuteStatementRequest.builder()
.resourceArn(System.getenv("ProxyHostName"))
.secretArn(System.getenv("DBUserName"))
.database(System.getenv("DBName"))
.sql("SELECT 'RDS IAM Authentication'")
.build();
// Execute request and obtain authentication token
ExecuteStatementResponse response = rdsDataClient.executeStatement(request);
Field tokenField = response.records().get(0).get(0);
return tokenField.stringValue();
}
}
```
------
#### [ JavaScript ]
**SDK for JavaScript (v3)**
GitHub에 더 많은 내용이 있습니다. [서버리스 예제](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-connect-rds-iam) 리포지토리에서 전체 예제를 찾아보고 설정 및 실행 방법을 알아봅니다.
JavaScript를 사용하여 Lambda 함수에서 Amazon RDS 데이터베이스에 연결
```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
/*
Node.js code here.
*/
// ES6+ example
import { Signer } from "@aws-sdk/rds-signer";
import mysql from 'mysql2/promise';
async function createAuthToken() {
// Define connection authentication parameters
const dbinfo = {
hostname: process.env.ProxyHostName,
port: process.env.Port,
username: process.env.DBUserName,
region: process.env.AWS_REGION,
}
// Create RDS Signer object
const signer = new Signer(dbinfo);
// Request authorization token from RDS, specifying the username
const token = await signer.getAuthToken();
return token;
}
async function dbOps() {
// Obtain auth token
const token = await createAuthToken();
// Define connection configuration
let connectionConfig = {
host: process.env.ProxyHostName,
user: process.env.DBUserName,
password: token,
database: process.env.DBName,
ssl: 'Amazon RDS'
}
// Create the connection to the DB
const conn = await mysql.createConnection(connectionConfig);
// Obtain the result of the query
const [res,] = await conn.execute('select ?+? as sum', [3, 2]);
return res;
}
export const handler = async (event) => {
// Execute database flow
const result = await dbOps();
// Return result
return {
statusCode: 200,
body: JSON.stringify("The selected sum is: " + result[0].sum)
}
};
```
TypeScript를 사용하여 Lambda 함수에서 Amazon RDS 데이터베이스에 연결
```
import { Signer } from "@aws-sdk/rds-signer";
import mysql from 'mysql2/promise';
// RDS settings
// Using '!' (non-null assertion operator) to tell the TypeScript compiler that the DB settings are not null or undefined,
const proxy_host_name = process.env.PROXY_HOST_NAME!
const port = parseInt(process.env.PORT!)
const db_name = process.env.DB_NAME!
const db_user_name = process.env.DB_USER_NAME!
const aws_region = process.env.AWS_REGION!
async function createAuthToken(): Promise {
// Create RDS Signer object
const signer = new Signer({
hostname: proxy_host_name,
port: port,
region: aws_region,
username: db_user_name
});
// Request authorization token from RDS, specifying the username
const token = await signer.getAuthToken();
return token;
}
async function dbOps(): Promise {
try {
// Obtain auth token
const token = await createAuthToken();
const conn = await mysql.createConnection({
host: proxy_host_name,
user: db_user_name,
password: token,
database: db_name,
ssl: 'Amazon RDS' // Ensure you have the CA bundle for SSL connection
});
const [rows, fields] = await conn.execute('SELECT ? + ? AS sum', [3, 2]);
console.log('result:', rows);
return rows;
}
catch (err) {
console.log(err);
}
}
export const lambdaHandler = async (event: any): Promise<{ statusCode: number; body: string }> => {
// Execute database flow
const result = await dbOps();
// Return error is result is undefined
if (result == undefined)
return {
statusCode: 500,
body: JSON.stringify(`Error with connection to DB host`)
}
// Return result
return {
statusCode: 200,
body: JSON.stringify(`The selected sum is: ${result[0].sum}`)
};
};
```
------
#### [ PHP ]
**SDK for PHP**
GitHub에 더 많은 내용이 있습니다. [서버리스 예제](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-connect-rds-iam) 리포지토리에서 전체 예제를 찾아보고 설정 및 실행 방법을 알아봅니다.
PHP를 사용하여 Lambda 함수에서 Amazon RDS 데이터베이스에 연결
```
logger = $logger;
}
private function getAuthToken(): string {
// Define connection authentication parameters
$dbConnection = [
'hostname' => getenv('DB_HOSTNAME'),
'port' => getenv('DB_PORT'),
'username' => getenv('DB_USERNAME'),
'region' => getenv('AWS_REGION'),
];
// Create RDS AuthTokenGenerator object
$generator = new AuthTokenGenerator(CredentialProvider::defaultProvider());
// Request authorization token from RDS, specifying the username
return $generator->createToken(
$dbConnection['hostname'] . ':' . $dbConnection['port'],
$dbConnection['region'],
$dbConnection['username']
);
}
private function getQueryResults() {
// Obtain auth token
$token = $this->getAuthToken();
// Define connection configuration
$connectionConfig = [
'host' => getenv('DB_HOSTNAME'),
'user' => getenv('DB_USERNAME'),
'password' => $token,
'database' => getenv('DB_NAME'),
];
// Create the connection to the DB
$conn = new PDO(
"mysql:host={$connectionConfig['host']};dbname={$connectionConfig['database']}",
$connectionConfig['user'],
$connectionConfig['password'],
[
PDO::MYSQL_ATTR_SSL_CA => '/path/to/rds-ca-2019-root.pem',
PDO::MYSQL_ATTR_SSL_VERIFY_SERVER_CERT => true,
]
);
// Obtain the result of the query
$stmt = $conn->prepare('SELECT ?+? AS sum');
$stmt->execute([3, 2]);
return $stmt->fetch(PDO::FETCH_ASSOC);
}
/**
* @param mixed $event
* @param Context $context
* @return array
*/
public function handle(mixed $event, Context $context): array
{
$this->logger->info("Processing query");
// Execute database flow
$result = $this->getQueryResults();
return [
'sum' => $result['sum']
];
}
}
$logger = new StderrLogger();
return new Handler($logger);
```
------
#### [ Python ]
**SDK for Python(Boto3)**
GitHub에 더 많은 내용이 있습니다. [서버리스 예제](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-connect-rds-iam) 리포지토리에서 전체 예제를 찾아보고 설정 및 실행 방법을 알아봅니다.
Python을 사용하여 Lambda 함수에서 Amazon RDS 데이터베이스에 연결
```
import json
import os
import boto3
import pymysql
# RDS settings
proxy_host_name = os.environ['PROXY_HOST_NAME']
port = int(os.environ['PORT'])
db_name = os.environ['DB_NAME']
db_user_name = os.environ['DB_USER_NAME']
aws_region = os.environ['AWS_REGION']
# Fetch RDS Auth Token
def get_auth_token():
client = boto3.client('rds')
token = client.generate_db_auth_token(
DBHostname=proxy_host_name,
Port=port
DBUsername=db_user_name
Region=aws_region
)
return token
def lambda_handler(event, context):
token = get_auth_token()
try:
connection = pymysql.connect(
host=proxy_host_name,
user=db_user_name,
password=token,
db=db_name,
port=port,
ssl={'ca': 'Amazon RDS'} # Ensure you have the CA bundle for SSL connection
)
with connection.cursor() as cursor:
cursor.execute('SELECT %s + %s AS sum', (3, 2))
result = cursor.fetchone()
return result
except Exception as e:
return (f"Error: {str(e)}") # Return an error message if an exception occurs
```
------
#### [ Ruby ]
**SDK for Ruby**
GitHub에 더 많은 내용이 있습니다. [서버리스 예제](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-connect-rds-iam) 리포지토리에서 전체 예제를 찾아보고 설정 및 실행 방법을 알아봅니다.
Ruby를 사용하여 Lambda 함수에서 Amazon RDS 데이터베이스에 연결
```
# Ruby code here.
require 'aws-sdk-rds'
require 'json'
require 'mysql2'
def lambda_handler(event:, context:)
endpoint = ENV['DBEndpoint'] # Add the endpoint without https"
port = ENV['Port'] # 3306
user = ENV['DBUser']
region = ENV['DBRegion'] # 'us-east-1'
db_name = ENV['DBName']
credentials = Aws::Credentials.new(
ENV['AWS_ACCESS_KEY_ID'],
ENV['AWS_SECRET_ACCESS_KEY'],
ENV['AWS_SESSION_TOKEN']
)
rds_client = Aws::RDS::AuthTokenGenerator.new(
region: region,
credentials: credentials
)
token = rds_client.auth_token(
endpoint: endpoint+ ':' + port,
user_name: user,
region: region
)
begin
conn = Mysql2::Client.new(
host: endpoint,
username: user,
password: token,
port: port,
database: db_name,
sslca: '/var/task/global-bundle.pem',
sslverify: true,
enable_cleartext_plugin: true
)
a = 3
b = 2
result = conn.query("SELECT #{a} + #{b} AS sum").first['sum']
puts result
conn.close
{
statusCode: 200,
body: result.to_json
}
rescue => e
puts "Database connection failed due to #{e}"
end
end
```
------
#### [ Rust ]
**SDK for Rust**
GitHub에 더 많은 내용이 있습니다. [서버리스 예제](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-connect-rds-iam) 리포지토리에서 전체 예제를 찾아보고 설정 및 실행 방법을 알아봅니다.
Rust를 사용하여 Lambda 함수에서 Amazon RDS 데이터베이스에 연결
```
use aws_config::BehaviorVersion;
use aws_credential_types::provider::ProvideCredentials;
use aws_sigv4::{
http_request::{sign, SignableBody, SignableRequest, SigningSettings},
sign::v4,
};
use lambda_runtime::{run, service_fn, Error, LambdaEvent};
use serde_json::{json, Value};
use sqlx::postgres::PgConnectOptions;
use std::env;
use std::time::{Duration, SystemTime};
const RDS_CERTS: &[u8] = include_bytes!("global-bundle.pem");
async fn generate_rds_iam_token(
db_hostname: &str,
port: u16,
db_username: &str,
) -> Result {
let config = aws_config::load_defaults(BehaviorVersion::v2024_03_28()).await;
let credentials = config
.credentials_provider()
.expect("no credentials provider found")
.provide_credentials()
.await
.expect("unable to load credentials");
let identity = credentials.into();
let region = config.region().unwrap().to_string();
let mut signing_settings = SigningSettings::default();
signing_settings.expires_in = Some(Duration::from_secs(900));
signing_settings.signature_location = aws_sigv4::http_request::SignatureLocation::QueryParams;
let signing_params = v4::SigningParams::builder()
.identity(&identity)
.region(®ion)
.name("rds-db")
.time(SystemTime::now())
.settings(signing_settings)
.build()?;
let url = format!(
"https://{db_hostname}:{port}/?Action=connect&DBUser={db_user}",
db_hostname = db_hostname,
port = port,
db_user = db_username
);
let signable_request =
SignableRequest::new("GET", &url, std::iter::empty(), SignableBody::Bytes(&[]))
.expect("signable request");
let (signing_instructions, _signature) =
sign(signable_request, &signing_params.into())?.into_parts();
let mut url = url::Url::parse(&url).unwrap();
for (name, value) in signing_instructions.params() {
url.query_pairs_mut().append_pair(name, &value);
}
let response = url.to_string().split_off("https://".len());
Ok(response)
}
#[tokio::main]
async fn main() -> Result<(), Error> {
run(service_fn(handler)).await
}
async fn handler(_event: LambdaEvent) -> Result {
let db_host = env::var("DB_HOSTNAME").expect("DB_HOSTNAME must be set");
let db_port = env::var("DB_PORT")
.expect("DB_PORT must be set")
.parse::()
.expect("PORT must be a valid number");
let db_name = env::var("DB_NAME").expect("DB_NAME must be set");
let db_user_name = env::var("DB_USERNAME").expect("DB_USERNAME must be set");
let token = generate_rds_iam_token(&db_host, db_port, &db_user_name).await?;
let opts = PgConnectOptions::new()
.host(&db_host)
.port(db_port)
.username(&db_user_name)
.password(&token)
.database(&db_name)
.ssl_root_cert_from_pem(RDS_CERTS.to_vec())
.ssl_mode(sqlx::postgres::PgSslMode::Require);
let pool = sqlx::postgres::PgPoolOptions::new()
.connect_with(opts)
.await?;
let result: i32 = sqlx::query_scalar("SELECT $1 + $2")
.bind(3)
.bind(2)
.fetch_one(&pool)
.await?;
println!("Result: {:?}", result);
Ok(json!({
"statusCode": 200,
"content-type": "text/plain",
"body": format!("The selected sum is: {result}")
}))
}
```
------
## Amazon RDS의 이벤트 알림 처리
Lambda를 사용하여 Amazon RDS 데이터베이스의 이벤트 알림을 처리할 수 있습니다. Amazon RDS는 Amazon Simple Notification Service(Amazon SNS) 주제에 알림을 전송합니다. 이 알림이 Lambda 함수를 간접 호출하도록 구성할 수 있습니다. Amazon SNS는 Amazon RDS의 메시지를 자체 이벤트 문서로 래핑하여 함수에 이를 전송합니다.
알림 전송을 위한 Amazon RDS 데이터베이스 구성에 대한 자세한 내용은 [Amazon RDS 이벤트 알림 사용](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_Events.html)을 참조하세요.
**Example Amazon SNS 이벤트의 Amazon RDS 메시지**
```
{
"Records": [
{
"EventVersion": "1.0",
"EventSubscriptionArn": "arn:aws:sns:us-east-2:123456789012:rds-lambda:21be56ed-a058-49f5-8c98-aedd2564c486",
"EventSource": "aws:sns",
"Sns": {
"SignatureVersion": "1",
"Timestamp": "2023-01-02T12:45:07.000Z",
"Signature": "tcc6faL2yUC6dgZdmrwh1Y4cGa/ebXEkAi6RibDsvpi+tE/1+82j...65r==",
"SigningCertUrl": "https://sns.us-east-2.amazonaws.com/SimpleNotificationService-ac565b8b1a6c5d002d285f9598aa1d9b.pem",
"MessageId": "95df01b4-ee98-5cb9-9903-4c221d41eb5e",
"Message": "{\"Event Source\":\"db-instance\",\"Event Time\":\"2023-01-02 12:45:06.000\",\"Identifier Link\":\"https://console.aws.amazon.com/rds/home?region=eu-west-1#dbinstance:id=dbinstanceid\",\"Source ID\":\"dbinstanceid\",\"Event ID\":\"http://docs.amazonwebservices.com/AmazonRDS/latest/UserGuide/USER_Events.html#RDS-EVENT-0002\",\"Event Message\":\"Finished DB Instance backup\"}",
"MessageAttributes": {},
"Type": "Notification",
"UnsubscribeUrl": "https://sns.us-east-2.amazonaws.com/?Action=Unsubscribe&SubscriptionArn=arn:aws:sns:us-east-2:123456789012:test-lambda:21be56ed-a058-49f5-8c98-aedd2564c486",
"TopicArn":"arn:aws:sns:us-east-2:123456789012:sns-lambda",
"Subject": "RDS Notification Message"
}
}
]
}
```
## Lambda 및 Amazon RDS 자습서 완료
+ [Amazon RDS 데이터베이스에 액세스하기 위해 Lambda 함수 사용](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/rds-lambda-tutorial.html) – Amazon RDS 사용자 설명서에서, Lambda 함수를 사용하여 Amazon RDS Proxy를 통해 Amazon RDS 데이터베이스에 데이터를 쓰는 방법을 알아보세요. Lambda 함수는 메시지가 추가될 때마다 Amazon SQS 대기열에서 레코드를 읽고 데이터베이스의 테이블에 새 항목을 기록합니다.
# Lambda 기반 애플리케이션에 대한 데이터베이스 서비스 선택
많은 서버리스 애플리케이션은 데이터를 저장하고 검색해야 합니다. AWS는 Lambda 함수에서 작동하는 여러 가지 데이터베이스 옵션을 제공합니다. 가장 인기 있는 두 가지 옵션은 NoSQL 데이터베이스 서비스인 Amazon DynamoDB와 기존 관계형 데이터베이스 솔루션인 Amazon RDS입니다. 다음 섹션에서는 이러한 서비스를 Lambda와 함께 사용할 때 이러한 서비스의 주요 차이점을 설명하며, 서버리스 애플리케이션에 적합한 데이터베이스 서비스를 선택할 수 있도록 지원합니다.
AWS에서 제공하는 다른 데이터베이스 서비스에 대해 자세히 알아보고, 사용 사례 및 장단점을 더욱 종합적으로 이해하려면 [Choosing an AWS database service](https://docs.aws.amazon.com/decision-guides/latest/databases-on-aws-how-to-choose/databases-on-aws-how-to-choose.html) 섹션을 참조하세요. 모든 AWS 데이터베이스 서비스는 Lambda와 호환되지만, 모든 데이터베이스 서비스가 특정 사용 사례에 적합한 것은 아닙니다.
## Lambda를 사용하여 데이터베이스 서비스를 선택할 때 고를 수 있는 옵션
AWS는 여러 가지 데이터베이스 서비스를 제공합니다. 서버리스 애플리케이션의 경우 가장 많이 사용되는 두 가지 옵션은 DynamoDB 및 Amazon RDS입니다.
+ **DynamoDB**는 서버리스 애플리케이션에 최적화된 완전 관리형 NoSQL 데이터베이스 서비스입니다. 모든 규모에서 원활한 규모 조정 및 일관된 한 자릿수 밀리초 성능을 제공합니다.
+ **Amazon RDS**는 MySQL 및 PostgreSQL을 비롯한 여러 데이터베이스 엔진을 지원하는 관리형 관계형 데이터베이스 서비스입니다. 관리형 인프라를 통해 익숙한 SQL 기능을 제공합니다.
## 권장 사항(요구 사항을 이미 알고 있는 경우)
요구 사항을 이미 명확히 알고 있는 경우 기본 권장 사항은 다음과 같습니다.
지연 시간이 짧은 일관된 성능, 자동 규모 조정이 필요하고 복잡한 조인 또는 트랜잭션을 요구하지 않는 서버리스 애플리케이션에 [DynamoDB](with-ddb.md)를 사용하는 것이 좋습니다. 이는 서버리스의 특성상 Lambda 기반 애플리케이션에 특히 적합합니다.
[Amazon RDS](services-rds.md)는 복잡한 SQL 쿼리, 조인이 필요하거나 관계형 데이터베이스를 사용하는 기존 애플리케이션이 있는 경우에 더 적합한 옵션입니다. 그러나 Lambda 함수를 Amazon RDS에 연결하려면 추가 구성이 필요하며, 콜드 스타트 시간에 영향을 미칠 수 있습니다.
## 데이터베이스 서비스를 선택할 때 고려해야 할 사항
Lambda 애플리케이션에 DynamoDB 및 Amazon RDS 중 어떤 걸 사용할지 선택할 경우 다음 요소를 고려하세요.
+ 연결 관리 및 콜드 스타트
+ 데이터 액세스 패턴
+ 쿼리 복잡성
+ 데이터 일관성 요구 사항
+ 규모 조정 특성
+ 비용 모델
이러한 요소를 이해하면 특정한 사용 사례의 요구 사항에 가장 적합한 옵션을 선택할 수 있습니다.
### 연결 관리 및 콜드 스타트
+ DynamoDB는 모든 작업에 HTTP API를 사용합니다. Lambda 함수는 연결을 유지하지 않고도 즉시 요청할 수 있으므로 콜드 스타트 성능이 향상됩니다. 각 요청은 연결 오버헤드 없이 AWS 자격 증명을 사용하여 인증됩니다.
+ Amazon RDS는 기존 데이터베이스 연결을 사용하기 때문에 연결 풀을 관리해야 합니다. 이 경우 새 Lambda 인스턴스가 연결을 설정해야 하므로 콜드 스타트에 영향을 미칠 수 있습니다. 연결 풀링 전략을 구현해야 하며 [Amazon RDS Proxy](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/rds-proxy.html)를 사용하여 연결을 효과적으로 관리해야 할 수 있습니다. Amazon RDS Proxy를 사용하면 추가 비용이 발생합니다.
### 데이터 액세스 패턴
+ DynamoDB는 알려진 액세스 패턴 및 단일 테이블 설계에 가장 적합합니다. 프라이머리 키 또는 보조 인덱스를 토대로 데이터에 대해 지연 시간이 짧은 일관된 액세스가 필요한 Lambda 애플리케이션에 적합합니다.
+ Amazon RDS는 복잡한 쿼리 및 변경되는 액세스 패턴을 위한 유연성을 제공합니다. Lambda 함수가 여러 테이블에서 고유한 맞춤형 쿼리 또는 복잡한 조인을 수행해야 하는 경우에 더 적합합니다.
### 쿼리 복잡성
+ DynamoDB는 간단한 키 기반 작업 및 사전 정의된 액세스 패턴에서 우수한 기능을 발휘합니다. 복잡한 쿼리는 인덱스 구조를 중심으로 설계되어야 하며, 조인은 애플리케이션 코드에서 처리되어야 합니다.
+ Amazon RDS는 조인, 하위 쿼리, 집계를 통해 복잡한 SQL 쿼리를 지원합니다. 이렇게 하면 복잡한 데이터 작업이 필요할 때 Lambda 함수 코드를 간소화할 수 있습니다.
### 데이터 일관성 요구 사항
+ DynamoDB는 단일 항목 읽기에 사용할 수 있는 강력한 일관성과 함께 최종 일관성 및 강력한 일관성 옵션을 모두 제공합니다. 트랜잭션이 지원되지만 몇 가지 제한 사항이 있습니다.
+ Amazon RDS는 완전한 원자성, 일관성, 격리, 내구성(ACID) 규정 준수 및 복잡한 트랜잭션 지원을 제공합니다. Lambda 함수에 복잡한 트랜잭션이 필요하거나 여러 레코드에 강력한 일관성이 필요한 경우 Amazon RDS가 더 적합할 수 있습니다.
### 규모 조정 특성
+ DynamoDB는 워크로드에 따라 자동으로 확장됩니다. 사전 프로비저닝 없이 Lambda 함수의 갑작스러운 트래픽 스파이크를 처리할 수 있습니다. 온디맨드 용량 모드를 사용하면 Lambda의 규모 조정 모델과 완벽하게 일치하는 사용량에 대해서만 비용을 지불할 수 있습니다.
+ Amazon RDS는 선택한 인스턴스 크기에 따라 용량이 고정됩니다. 여러 Lambda 함수가 동시에 연결을 시도할 경우 연결 할당량을 초과할 수 있습니다. 연결 풀을 꼼꼼하게 관리하고 재시도 로직을 구현해야 합니다.
### 비용 모델
+ DynamoDB의 요금은 서버리스 애플리케이션과 잘 맞습니다. 온디맨드 용량을 사용하면 Lambda 함수에서 수행한 실제 읽기 및 쓰기에 대해서만 비용을 지불합니다. 유휴 시간에는 요금이 부과되지 않습니다.
+ Amazon RDS는 사용량과 관계없이 실행 중인 인스턴스에 대해 요금을 청구합니다. 이렇게 되면 서버리스 애플리케이션에서 일반적으로 일어날 수 있는 산발적인 워크로드의 경우 비용 효율성이 떨어질 수 있습니다. 그러나 사용량이 일관되면서 처리량이 많은 워크로드의 경우에는 더 경제적일 수 있습니다.
## 선택한 데이터베이스 서비스 시작하기
이제 DynamoDB 및 Amazon RDS 중 하나를 선택하는 기준과 이들 간의 주요 차이에 대해 알아보았으니, 요구 사항과 가장 일치하는 옵션을 선택하고 다음 리소스를 사용하여 사용을 시작할 수 있습니다.
------
#### [ DynamoDB ]
**다음 리소스를 사용하여 DynamoDB 시작하기**
+ DynamoDB 서비스에 대한 소개는 **Amazon DynamoDB 개발자 가이드의 [What is DynamoDB?](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) 섹션을 참조하세요.
+ [API Gateway에서 Lambda 사용](services-apigateway-tutorial.md) 자습서를 따라 API 요청에 대한 응답으로 Lambda 함수를 사용하여 DynamoDB 테이블에서 CRUD 작업을 수행하는 예제를 확인합니다.
+ **Amazon DynamoDB 개발자 안내서의 [DynamoDB 및 AWS SDK를 사용한 프로그래밍](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Programming.html) 섹션을 읽고 AWS SDK 중 하나를 사용하여 Lambda 함수 내에서 DynamoDB에 액세스하는 방법을 자세히 알아봅니다.
------
#### [ Amazon RDS ]
**다음 리소스를 사용하여 Amazon RDS 시작하기**
+ Amazon RDS 서비스에 대한 소개는 **Amazon Relational Database Service 사용 설명서의 [Amazon Relational Database Service(Amazon RDS)란 무엇입니까?](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Welcome.html) 섹션을 참조하세요.
+ *Amazon Relational Database 사용 설명서*의 [Amazon RDS에 액세스하기 위해 Lambda 함수 사용](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/rds-lambda-tutorial.html) 자습서를 따릅니다.
+ [Amazon RDS와 함께 AWS Lambda 사용](services-rds.md) 섹션을 읽고 Amazon RDS와 함께 Lambda를 사용하는 방법을 자세히 알아봅니다.
------