Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Verwendung AWS Lambda mit Amazon RDS
Sie können eine Lambda-Funktion direkt und über einen Amazon-RDS-Proxy mit einer Amazon Relational Database Service (Amazon RDS)-Datenbank verbinden. Direkte Verbindungen sind in einfachen Szenarien nützlich, und Proxys werden für die Produktion empfohlen. Ein Datenbank-Proxy verwaltet einen Pool gemeinsam genutzter Datenbankverbindungen, sodass Ihre Funktion eine hohe Gleichkeitigkeitsstufe erreichen kann, ohne dass die Datenbankverbindungen erschöpft werden.
Wir empfehlen die Verwendung von Amazon-RDS-Proxy für Lambda-Funktionen, die häufig kurze Datenbankverbindungen herstellen oder eine große Anzahl von Datenbankverbindungen öffnen und schließen. Weitere Informationen finden Sie unter [Automatisches Verbinden einer Lambda-Funktion und einer DB-Instance](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/lambda-rds-connect.html) im Amazon Relational Database Service Developer Guide.
**Tipp**
Um eine Lambda-Funktion schnell mit einer Amazon-RDS-Datenbank zu verbinden, können Sie den Assistenten verwenden, der in die Konsole integriert ist. Gehen Sie wie folgt vor, um den Assistenten zu öffnen:
Öffnen Sie die Seite [Funktionen](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole.
Wählen Sie die Funktion aus, mit der Sie eine Datenbank verbinden möchten.
Wählen Sie auf der Registerkarte **Konfiguration** die Option **RDS-Datenbanken** aus.
Wählen Sie **Verbindung zur RDS-Datenbank herstellen** aus.
Nachdem Sie Ihre Funktion mit einer Datenbank verbunden haben, können Sie über die Option **Proxy hinzufügen** einen Proxy erstellen.
## Konfiguration Ihrer Funktion für die Verwendung mit RDS-Ressourcen
In der Lambda-Konsole können Sie Amazon-RDS-Datenbankinstanzen und Proxy-Ressourcen bereitstellen und konfigurieren. Sie können dies tun, indem Sie auf der Registerkarte **Konfiguration** zu den **RDS-Datenbanken** navigieren. Alternativ können Sie auch Verbindungen zu Lambda-Funktionen in der Amazon-RDS-Konsole erstellen und konfigurieren. Wenn Sie eine RDS-Datenbank-Instance für die Verwendung mit Lambda konfigurieren, beachten Sie die folgenden Kriterien:
+ Um eine Verbindung zu einer Datenbank herzustellen, muss sich die Funktion in derselben Amazon VPC befinden, in der Ihre Datenbank ausgeführt wird.
+ Sie können Amazon-RDS-Datenbanken mit MySQL-, MariaDB-, PostgreSQL- oder Microsoft-SQL-Server-Engines verwenden.
+ Sie können Aurora-DB-Cluster auch mit MySQL- oder PostgreSQL-Engines verwenden.
+ Sie müssen ein Secrets-Manager-Geheimnis für die Authentifizierung der Datenbank angeben.
+ Eine IAM-Rolle muss die Berechtigung zur Verwendung des Geheimnisses sowie eine Vertrauensrichtlinie bereitstellen, mit der Amazon RDS die Rolle übernehmen kann.
+ Der IAM-Prinzipal, der die Konsole verwendet, um die Amazon-RDS-Ressource zu konfigurieren und sie mit Ihrer Funktion zu verbinden, muss über die folgenden Berechtigungen verfügen:
### Beispiel für eine Berechtigungsrichtlinie
**Anmerkung**
Sie benötigen die Amazon-RDS-Proxy Berechtigungen nur, wenn Sie einen Amazon-RDS-Proxy konfigurieren, um einen Pool Ihrer Datenbankverbindungen zu verwalten.
------
#### [ 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 berechnet einen Stundensatz für Proxys, der auf der Größe der Datenbank-Instance basiert. Weitere Informationen finden Sie unter [RDS-Proxy-Preise](https://aws.amazon.com/rds/proxy/pricing/). Weitere Informationen zu Proxy-Verbindungen finden Sie unter [Verwendung von Amazon-RDS-Proxy](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/rds-proxy.html) im Amazon-RDS-Benutzerhandbuch.
### SSL/TLS-Anforderungen für Amazon-RDS-Verbindungen
Um sichere SSL/TLS Verbindungen zu einer Amazon RDS-Datenbank-Instance herzustellen, muss Ihre Lambda-Funktion die Identität des Datenbankservers mithilfe eines vertrauenswürdigen Zertifikats verifizieren. Lambda verarbeitet diese Zertifikate je nach Art Ihres Bereitstellungspakets unterschiedlich:
+ [ZIP-Dateiarchive](configuration-function-zip.md): Die Zertifikatsverarbeitung variiert je nach Laufzeit:
+ **Node.js 18 und früher**: Lambda schließt automatisch CA-Zertifikate und RDS-Zertifikate ein.
+ **Node.js 20 und höher**: Lambda lädt standardmäßig keine zusätzlichen CA-Zertifikate mehr. Legen Sie die Umgebungsvariable `NODE_EXTRA_CA_CERTS` auf `/var/runtime/ca-cert.pem` fest.
Es kann bis zu 4 Wochen dauern, bis Amazon RDS-Zertifikate AWS-Regionen zu den verwalteten Lambda-Laufzeiten hinzugefügt werden.
+ [Container-Images](images-create.md): AWS Basis-Images enthalten nur CA-Zertifikate. Wenn Ihre Funktion eine Verbindung zu einer Amazon-RDS-Datenbank-Instance herstellt, müssen Sie die entsprechenden Zertifikate in Ihr Container-Image einbinden. Laden Sie in Ihrem Dockerfile das [Zertifikatspaket herunter, das dem entspricht, AWS-Region wo Sie Ihre Datenbank hosten](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/UsingWithRDS.SSL.html#UsingWithRDS.SSL.CertificatesDownload). Beispiel:
```
RUN curl https://truststore.pki.rds.amazonaws.com/us-east-1/us-east-1-bundle.pem -o /us-east-1-bundle.pem
```
Mit diesem Befehl wird das Amazon-RDS-Zertifikatspaket heruntergeladen und im absoluten Pfad `/us-east-1-bundle.pem` im Stammverzeichnis Ihres Containers gespeichert. Beim Konfigurieren der Datenbankverbindung in Ihrem Funktionscode müssen Sie genau diesen Pfad angeben. Beispiel:
------
#### [ Node.js ]
Die Funktion „`readFileSync`“ ist erforderlich, da Node.js-Datenbankclients den eigentlichen Zertifikatsinhalt im Speicher benötigen, nicht nur den Pfad zur Zertifikatsdatei. Ohne „`readFileSync`“ interpretiert der Client die Pfadzeichenfolge als Zertifikatsinhalt, was zu dem Fehler „Selbstsigniertes Zertifikat in der Zertifikatskette“ führt.
**Example Node.js-Verbindungskonfiguration für die OCI-Funktion**
```
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 Python-Verbindungskonfiguration für die OCI-Funktion**
```
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 ]
Für Java-Funktionen mit JDBC-Verbindungen muss die Verbindungszeichenfolge Folgendes enthalten:
+ `useSSL=true`
+ `requireSSL=true`
+ Einen `sslCA`-Parameter, der auf den Speicherort des Amazon-RDS-Zertifikats im Container-Image verweist
**Example Java-Verbindungszeichenfolge für die OCI-Funktion**
```
// 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 .NET-Verbindungszeichenfolge für MySQL-Verbindung in der OCI-Funktion**
```
/// 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 ]
Für Go-Funktionen mit MySQL-Verbindungen laden Sie das Amazon-RDS-Zertifikat in einen Zertifikatspool und registrieren es beim MySQL-Treiber. Die Verbindungszeichenfolge muss dann mithilfe des `tls`-Parameters auf diese Konfiguration verweisen.
**Example Go-Code für MySQL-Verbindung in der OCI-Funktion**
```
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 Ruby-Verbindungskonfiguration für die OCI-Funktion**
```
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
)
```
------
## Herstellen einer Verbindung mit einer Amazon-RDS-Datenbank in einer Lambda-Funktion
Die folgenden Codebeispiele veranschaulichen, wie eine Lambda-Funktion implementiert wird, die eine Verbindung zu einer Amazon-RDS-Datenbank herstellt. Die Funktion stellt eine einfache Datenbankanfrage und gibt das Ergebnis zurück.
**Anmerkung**
Diese Codebeispiele gelten nur für [ZIP-Bereitstellungspakete](configuration-function-zip.md). Wenn Sie Ihre Funktion mithilfe eines [Container-Images](images-create.md) bereitstellen, müssen Sie die Amazon-RDS-Zertifikatsdatei in Ihrem Funktionscode angeben, wie im [vorherigen Abschnitt](#oci-certificate) beschrieben.
------
#### [ .NET ]
**SDK für .NET**
Es gibt noch mehr dazu. GitHub Das vollständige Beispiel sowie eine Anleitung zum Einrichten und Ausführen finden Sie im Repository mit [Serverless-Beispielen](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-connect-rds-iam).
Herstellen einer Verbindung mit einer Amazon-RDS-Datenbank in einer Lambda-Funktion mithilfe von .NET.
```
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 für Go V2**
Es gibt noch mehr GitHub. Das vollständige Beispiel sowie eine Anleitung zum Einrichten und Ausführen finden Sie im Repository mit [Serverless-Beispielen](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-connect-rds-iam).
Herstellen einer Verbindung zu einer Amazon-RDS-Datenbank in einer Lambda-Funktion mit Go.
```
/*
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 für Java 2.x**
Es gibt noch mehr GitHub. Das vollständige Beispiel sowie eine Anleitung zum Einrichten und Ausführen finden Sie im Repository mit [Serverless-Beispielen](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-connect-rds-iam).
Herstellen einer Verbindung zu einer Amazon-RDS-Datenbank in einer Lambda-Funktion mit Java.
```
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 für JavaScript (v3)**
Es gibt noch mehr dazu GitHub. Das vollständige Beispiel sowie eine Anleitung zum Einrichten und Ausführen finden Sie im Repository mit [Serverless-Beispielen](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-connect-rds-iam).
Herstellen einer Verbindung zu einer Amazon RDS-Datenbank in einer Lambda-Funktion mithilfe von JavaScript.
```
// 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)
}
};
```
Herstellen einer Verbindung zu einer Amazon RDS-Datenbank in einer Lambda-Funktion mithilfe von TypeScript.
```
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 für PHP**
Es gibt noch mehr dazu. GitHub Das vollständige Beispiel sowie eine Anleitung zum Einrichten und Ausführen finden Sie im Repository mit [Serverless-Beispielen](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-connect-rds-iam).
Herstellen einer Verbindung zu einer Amazon-RDS-Datenbank in einer Lambda-Funktion mit PHP.
```
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 für Python (Boto3)**
Es gibt noch mehr GitHub. Das vollständige Beispiel sowie eine Anleitung zum Einrichten und Ausführen finden Sie im Repository mit [Serverless-Beispielen](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-connect-rds-iam).
Herstellen einer Verbindung zu einer Amazon-RDS-Datenbank in einer Lambda-Funktion mit Python.
```
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 für Ruby**
Es gibt noch mehr GitHub. Das vollständige Beispiel sowie eine Anleitung zum Einrichten und Ausführen finden Sie im Repository mit [Serverless-Beispielen](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-connect-rds-iam).
Herstellen einer Verbindung zu einer Amazon-RDS-Datenbank in einer Lambda-Funktion mit Ruby.
```
# 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 für Rust**
Es gibt noch mehr dazu GitHub. Das vollständige Beispiel sowie eine Anleitung zum Einrichten und Ausführen finden Sie im Repository mit [Serverless-Beispielen](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-connect-rds-iam).
Herstellen einer Verbindung zu einer Amazon-RDS-Datenbank in einer Lambda-Funktion mit Rust.
```
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}")
}))
}
```
------
## Verarbeitung von Ereignisbenachrichtigungen von Amazon RDS
Sie können Lambda verwenden, um Ereignisbenachrichtigungen aus einer Amazon-RDS-Datenbank zu verarbeiten. Amazon RDS sendet Benachrichtigungen an ein Amazon-Simple-Notification-Service-(Amazon-SNS)-Thema, das Sie so konfigurieren können, dass eine Lambda-Funktion aufgerufen wird. Amazon SNS wickelt die Nachricht von Amazon RDS in ein eigenes Ereignisdokument und sendet sie an Ihre Funktion.
Weitere Informationen zum Konfigurieren einer Amazon-RDS-Datenbank zum Senden von Benachrichtigungen finden Sie unter [Verwendung von Amazon-RDS-Ereignisbenachrichtigungen](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_Events.html).
**Example Amazon-RDS-Nachricht in einem Amazon-SNS-Ereignis**
```
{
"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"
}
}
]
}
```
## Vollständiges Lambda- und Amazon-RDS-Tutorial
+ [Verwendung einer Lambda-Funktion für den Zugriff auf eine Amazon-RDS-Datenbank](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/rds-lambda-tutorial.html) – Im Benutzerhandbuch zu Amazon RDS wird beschrieben, wie Sie eine Lambda-Funktion verwenden, um Daten über einen Amazon-RDS-Proxy in eine Amazon-RDS-Datenbank zu schreiben. Ihre Lambda-Funktion liest Datensätze aus einer Amazon-SQS-Warteschlange und schreibt jedes Mal, wenn eine Nachricht hinzugefügt wird, neue Elemente in eine Tabelle in Ihrer Datenbank.
# Wählen Sie einen Datenbankservice für Ihre Lambda-basierten Anwendungen.
Viele serverlose Anwendungen müssen Daten speichern und abrufen. AWS bietet mehrere Datenbankoptionen, die mit Lambda-Funktionen funktionieren. Zwei der beliebtesten Optionen sind Amazon DynamoDB, ein NoSQL-Datenbankservice, und Amazon RDS, eine traditionelle relationale Datenbanklösung. In den folgenden Abschnitten werden die wichtigsten Unterschiede zwischen diesen Services bei der Verwendung mit Lambda erläutert und Sie bei der Auswahl des passenden Datenbankservices für Ihre Serverless-Anwendung unterstützt.
Weitere Informationen über die anderen von AWS angebotenen Datenbankdienste und ein allgemeines Verständnis ihrer Anwendungsfälle und Kompromisse finden Sie unter [Auswahl eines AWS](https://docs.aws.amazon.com/decision-guides/latest/databases-on-aws-how-to-choose/databases-on-aws-how-to-choose.html) Datenbankdienstes. Alle AWS -Datenbankservices sind mit Lambda kompatibel, aber nicht alle eignen sich für Ihren speziellen Anwendungsfall.
## Welche Möglichkeiten haben Sie bei der Auswahl eines Datenbankservices für Lambda?
AWS bietet mehrere Datenbankdienste an. Für Serverless-Anwendungen sind DynamoDB und Amazon RDS zwei der beliebtesten Optionen.
+ **DynamoDB** ist ein vollständig verwalteter NoSQL-Datenbankservice, der für Serverless-Anwendungen optimiert ist. Er bietet nahtlose Skalierung und eine konsistente Leistung im einstelligen Millisekundenbereich in jeder Größenordnung.
+ **Amazon RDS** ist ein verwalteter relationaler Datenbankservice, der mehrere Datenbank-Engines unterstützt, darunter MySQL und PostgreSQL. Er bietet vertraute SQL-Funktionen mit verwalteter Infrastruktur.
## Empfehlungen, falls Sie Ihre Anforderungen bereits kennen
Wenn Sie sich über Ihre Anforderungen bereits im Klaren sind, finden Sie hier unsere grundlegenden Empfehlungen:
Wir empfehlen [DynamoDB](with-ddb.md) für Serverless-Anwendungen, die eine konsistente Leistung mit niedriger Latenz und automatische Skalierung benötigen und keine komplexen Verknüpfungen oder Transaktionen erfordern. Aufgrund seiner Serverless-Architektur eignet er sich besonders gut für Lambda-basierte Anwendungen.
[Amazon RDS](services-rds.md) ist die bessere Wahl, wenn Sie komplexe SQL-Abfragen oder Verknüpfungen benötigen oder bereits Anwendungen mit relationalen Datenbanken verwenden. Beachten Sie jedoch, dass die Verbindung von Lambda-Funktionen mit Amazon RDS zusätzliche Konfigurationen erfordert und die Kaltstartzeiten beeinflussen kann.
## Was Sie bei der Auswahl eines Datenbankservices beachten sollten
Bei der Auswahl zwischen DynamoDB und Amazon RDS für Ihre Lambda-Anwendungen sollten Sie die folgenden Faktoren berücksichtigen:
+ Verbindungsmanagement und Kaltstarts
+ Datenzugriffsmuster
+ Abfragekomplexität
+ Anforderungen für Datenkonsistenz.
+ Skalierungsmerkmale
+ Kostenmodell
Wenn Sie diese Faktoren verstehen, können Sie die Option auswählen, die Ihren spezifischen Anwendungsfällen am besten entspricht.
### Verbindungsmanagement und Kaltstarts
+ DynamoDB verwendet eine HTTP-API für alle Operationen. Lambda-Funktionen können Anfragen sofort stellen, ohne Verbindungen aufrechtzuerhalten, was zu einer besseren Kaltstartleistung führt. Jede Anfrage wird mithilfe von AWS Anmeldeinformationen ohne Verbindungsaufwand authentifiziert.
+ Amazon RDS erfordert die Verwaltung von Verbindungspools, da es herkömmliche Datenbankverbindungen verwendet. Dies kann sich auf Kaltstarts auswirken, da neue Lambda-Instances Verbindungen herstellen müssen. Sie müssen Strategien für das Verbindungspooling implementieren und möglicherweise den [Amazon-RDS-Proxy](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/rds-proxy.html) verwenden, um Verbindungen effektiv zu verwalten. Beachten Sie, dass für die Verwendung des Amazon-RDS-Proxy zusätzliche Kosten anfallen.
### Datenzugriffsmuster
+ DynamoDB eignet sich am besten für bekannte Zugriffsmuster und Einzeltabellendesigns. Es ist ideal für Lambda-Anwendungen, die einen konsistenten Zugriff mit geringer Latenz auf Daten basierend auf Primärschlüsseln oder Sekundärindizes benötigen.
+ Amazon RDS bietet Flexibilität für komplexe Abfragen und sich ändernde Zugriffsmuster. Es ist besser geeignet, wenn Ihre Lambda-Funktionen einzigartige, maßgeschneiderte Abfragen oder komplexe Verknüpfungen über mehrere Tabellen hinweg durchführen müssen.
### Abfragekomplexität
+ DynamoDB zeichnet sich durch einfache, schlüsselbasierte Operationen und vordefinierte Zugriffsmuster aus. Komplexe Abfragen müssen um Indexstrukturen herum entworfen werden, und Verknüpfungen müssen im Anwendungscode behandelt werden.
+ Amazon RDS unterstützt komplexe SQL-Abfragen mit Verknüpfungen, Unterabfragen und Aggregationen. Dies kann Ihren Lambda-Funktionscode vereinfachen, wenn komplexe Datenoperationen erforderlich sind.
### Anforderungen für Datenkonsistenz.
+ DynamoDB bietet sowohl Optionen für letztendliche als auch für starke Konsistenz, wobei starke Konsistenz für Lesevorgänge einzelner Elemente verfügbar ist. Transaktionen werden unterstützt, jedoch mit einigen Einschränkungen.
+ Amazon RDS bietet vollständige ACID-Konformität (Atomizität, Konsistenz, Isolierung und Zuverlässigkeit) sowie Unterstützung für komplexe Transaktionen. Wenn Ihre Lambda-Funktionen komplexe Transaktionen oder starke Konsistenz über mehrere Datensätze hinweg benötigen, ist Amazon RDS möglicherweise besser geeignet.
### Skalierungsmerkmale
+ DynamoDB skaliert automatisch mit Ihrer Workload. Es kann plötzliche Spitzen im Datenverkehr durch Lambda-Funktionen ohne vorherige Bereitstellung bewältigen. Sie können den On-Demand-Kapazitätsmodus verwenden, um nur für das zu bezahlen, was Sie tatsächlich nutzen. Dies entspricht perfekt dem Skalierungsmodell von Lambda.
+ Amazon RDS verfügt über eine feste Kapazität, die auf der von Ihnen ausgewählten Instance-Größe basiert. Wenn mehrere Lambda-Funktionen versuchen, gleichzeitig eine Verbindung herzustellen, überschreiten Sie möglicherweise Ihr Verbindungskontingent. Sie müssen die Verbindungspools sorgfältig verwalten und möglicherweise eine Wiederholungslogik implementieren.
### Kostenmodell
+ Die Preisgestaltung von DynamoDB ist gut auf Serverless-Anwendungen abgestimmt. Mit On-Demand-Kapazität zahlen Sie nur für die tatsächlichen Lese- und Schreibvorgänge Ihrer Lambda-Funktionen. Für Leerlaufzeiten fallen keine Gebühren an.
+ Amazon RDS berechnet Gebühren für die laufende Instance unabhängig von der Nutzung. Dies kann bei sporadischen Workloads, wie sie in Serverless-Anwendungen typisch sind, weniger kosteneffizient sein. Für Workloads mit hohem Durchsatz und konstanter Nutzung kann es jedoch wirtschaftlicher sein.
## Erste Schritte mit dem von Ihnen ausgewählten Datenbankservice
Nachdem Sie die Auswahlkriterien für DynamoDB und Amazon RDS sowie die wichtigsten Unterschiede kennengelernt haben, können Sie die Option wählen, die Ihren Bedürfnissen am besten entspricht, und mithilfe der folgenden Ressourcen loslegen.
------
#### [ DynamoDB ]
**Nutzen Sie die folgenden Ressourcen, um mit DynamoDB zu beginnen**
+ Eine Einführung in den DynamoDB-Service finden Sie im *Entwicklerhandbuch für Amazon DynamoDB* unter [Was ist DynamoDB?](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html).
+ Im Tutorial [Verwenden von Lambda mit API Gateway](services-apigateway-tutorial.md) sehen Sie ein Beispiel für die Verwendung einer Lambda-Funktion zum Ausführen von CRUD-Vorgängen in einer DynamoDB-Tabelle als Antwort auf eine API-Anfrage.
+ Lesen Sie [Programming with DynamoDB und die AWS SDKs](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Programming.html) im *Amazon DynamoDB Developer Guide*, um mehr darüber zu erfahren, wie Sie von Ihrer Lambda-Funktion aus auf DynamoDB zugreifen können, indem Sie eine der AWS SDKs
------
#### [ Amazon RDS ]
**Nutzen Sie die folgenden Ressourcen, um mit Amazon RDS zu beginnen**
+ Eine Einführung in den Amazon-RDS-Service finden Sie im Abschnitt [Was ist Amazon Relational Database Service (Amazon RDS)?](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Welcome.html) im *Benutzerhandbuch zu Amazon Relational Database Service*.
+ Folgen Sie dem Tutorial [Verwenden einer Lambda-Funktion für den Zugriff auf eine Amazon-RDS-Datenbank](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/rds-lambda-tutorial.html) im *Benutzerhandbuch zu Amazon Relational Database Service*.
+ Weitere Informationen zur Verwendung von Lambda mit Amazon RDS finden Sie unter [Verwendung AWS Lambda mit Amazon RDS](services-rds.md).
------