文档 AWS SDK 示例 GitHub 存储库中还有更多 [S AWS DK 示例](https://github.com/awsdocs/aws-doc-sdk-examples)。
本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。
# 使用适用于 Ruby 的 SDK 的 Lambda 示例
以下代码示例向您展示了如何使用 with Lambda 来执行操作和实现常见场景。 适用于 Ruby 的 AWS SDK
*基本功能*是向您展示如何在服务中执行基本操作的代码示例。
*操作*是大型程序的代码摘录，必须在上下文中运行。您可以通过操作了解如何调用单个服务函数，还可以通过函数相关场景的上下文查看操作。
*场景*是向您演示如何通过在一个服务中调用多个函数或与其他 AWS 服务结合来完成特定任务的代码示例。
每个示例都包含一个指向完整源代码的链接，您可以从中找到有关如何在上下文中设置和运行代码的说明。
**Topics**
+ [开始使用](#get_started)
+ [基本功能](#basics)
+ [操作](#actions)
+ [场景](#scenarios)
+ [无服务器示例](#serverless_examples)
## 开始使用
### 开始使用 Lambda
以下代码示例展示了如何开始使用 Lambda。
**适用于 Ruby 的 SDK**
还有更多相关信息 GitHub。在 [AWS 代码示例存储库](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/ruby/example_code/lambda#code-examples)中查找完整示例，了解如何进行设置和运行。
```
require 'aws-sdk-lambda'
# Creates an AWS Lambda client using the default credentials and configuration
def lambda_client
Aws::Lambda::Client.new
end
# Lists the Lambda functions in your AWS account, paginating the results if necessary
def list_lambda_functions
lambda = lambda_client
# Use a pagination iterator to list all functions
functions = []
lambda.list_functions.each_page do |page|
functions.concat(page.functions)
end
# Print the name and ARN of each function
functions.each do |function|
puts "Function name: #{function.function_name}"
puts "Function ARN: #{function.function_arn}"
puts
end
puts "Total functions: #{functions.count}"
end
list_lambda_functions if __FILE__ == $PROGRAM_NAME
```
+ 有关 API 的详细信息，请参阅 *适用于 Ruby 的 AWS SDK API 参考[ListFunctions](https://docs.aws.amazon.com/goto/SdkForRubyV3/lambda-2015-03-31/ListFunctions)*中的。
## 基本功能
### 了解基本功能
以下代码示例展示了如何：
+ 创建 IAM 角色和 Lambda 函数，然后上传处理程序代码。
+ 使用单个参数来调用函数并获取结果。
+ 更新函数代码并使用环境变量进行配置。
+ 使用新参数来调用函数并获取结果。显示返回的执行日志。
+ 列出账户函数，然后清除函数。
有关更多信息，请参阅[使用控制台创建 Lambda 函数](https://docs.aws.amazon.com/lambda/latest/dg/getting-started-create-function.html)。
**适用于 Ruby 的 SDK**
还有更多相关信息 GitHub。在 [AWS 代码示例存储库](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/ruby/example_code/lambda#code-examples)中查找完整示例，了解如何进行设置和运行。
为能够写入日志的 Lambda 函数设置必备的 IAM 权限。
```
# Get an AWS Identity and Access Management (IAM) role.
#
# @param iam_role_name: The name of the role to retrieve.
# @param action: Whether to create or destroy the IAM apparatus.
# @return: The IAM role.
def manage_iam(iam_role_name, action)
case action
when 'create'
create_iam_role(iam_role_name)
when 'destroy'
destroy_iam_role(iam_role_name)
else
raise "Incorrect action provided. Must provide 'create' or 'destroy'"
end
end
private
def create_iam_role(iam_role_name)
role_policy = {
'Version': '2012-10-17',
'Statement': [
{
'Effect': 'Allow',
'Principal': { 'Service': 'lambda.amazonaws.com' },
'Action': 'sts:AssumeRole'
}
]
}
role = @iam_client.create_role(
role_name: iam_role_name,
assume_role_policy_document: role_policy.to_json
)
@iam_client.attach_role_policy(
{
policy_arn: 'arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole',
role_name: iam_role_name
}
)
wait_for_role_to_exist(iam_role_name)
@logger.debug("Successfully created IAM role: #{role['role']['arn']}")
sleep(10)
[role, role_policy.to_json]
end
def destroy_iam_role(iam_role_name)
@iam_client.detach_role_policy(
{
policy_arn: 'arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole',
role_name: iam_role_name
}
)
@iam_client.delete_role(role_name: iam_role_name)
@logger.debug("Detached policy & deleted IAM role: #{iam_role_name}")
end
def wait_for_role_to_exist(iam_role_name)
@iam_client.wait_until(:role_exists, { role_name: iam_role_name }) do |w|
w.max_attempts = 5
w.delay = 5
end
end
```
定义一个 Lambda 处理程序，用以递增作为调用参数提供的数字。
```
require 'logger'
# A function that increments a whole number by one (1) and logs the result.
# Requires a manually-provided runtime parameter, 'number', which must be Int
#
# @param event [Hash] Parameters sent when the function is invoked
# @param context [Hash] Methods and properties that provide information
# about the invocation, function, and execution environment.
# @return incremented_number [String] The incremented number.
def lambda_handler(event:, context:)
logger = Logger.new($stdout)
log_level = ENV['LOG_LEVEL']
logger.level = case log_level
when 'debug'
Logger::DEBUG
when 'info'
Logger::INFO
else
Logger::ERROR
end
logger.debug('This is a debug log message.')
logger.info('This is an info log message. Code executed successfully!')
number = event['number'].to_i
incremented_number = number + 1
logger.info("You provided #{number.round} and it was incremented to #{incremented_number.round}")
incremented_number.round.to_s
end
```
将 Lambda 函数压缩到部署程序包中。
```
# Creates a Lambda deployment package in .zip format.
#
# @param source_file: The name of the object, without suffix, for the Lambda file and zip.
# @return: The deployment package.
def create_deployment_package(source_file)
Dir.chdir(File.dirname(__FILE__))
if File.exist?('lambda_function.zip')
File.delete('lambda_function.zip')
@logger.debug('Deleting old zip: lambda_function.zip')
end
Zip::File.open('lambda_function.zip', create: true) do |zipfile|
zipfile.add('lambda_function.rb', "#{source_file}.rb")
end
@logger.debug("Zipping #{source_file}.rb into: lambda_function.zip.")
File.read('lambda_function.zip').to_s
rescue StandardError => e
@logger.error("There was an error creating deployment package:\n #{e.message}")
end
```
新建 Lambda 函数。
```
# Deploys a Lambda function.
#
# @param function_name: The name of the Lambda function.
# @param handler_name: The fully qualified name of the handler function.
# @param role_arn: The IAM role to use for the function.
# @param deployment_package: The deployment package that contains the function code in .zip format.
# @return: The Amazon Resource Name (ARN) of the newly created function.
def create_function(function_name, handler_name, role_arn, deployment_package)
response = @lambda_client.create_function({
role: role_arn.to_s,
function_name: function_name,
handler: handler_name,
runtime: 'ruby2.7',
code: {
zip_file: deployment_package
},
environment: {
variables: {
'LOG_LEVEL' => 'info'
}
}
})
@lambda_client.wait_until(:function_active_v2, { function_name: function_name }) do |w|
w.max_attempts = 5
w.delay = 5
end
response
rescue Aws::Lambda::Errors::ServiceException => e
@logger.error("There was an error creating #{function_name}:\n #{e.message}")
rescue Aws::Waiters::Errors::WaiterFailed => e
@logger.error("Failed waiting for #{function_name} to activate:\n #{e.message}")
end
```
使用可选的运行时参数调用 Lambda 函数。
```
# Invokes a Lambda function.
# @param function_name [String] The name of the function to invoke.
# @param payload [nil] Payload containing runtime parameters.
# @return [Object] The response from the function invocation.
def invoke_function(function_name, payload = nil)
params = { function_name: function_name }
params[:payload] = payload unless payload.nil?
@lambda_client.invoke(params)
rescue Aws::Lambda::Errors::ServiceException => e
@logger.error("There was an error executing #{function_name}:\n #{e.message}")
end
```
更新 Lambda 函数的配置，以注入新的环境变量。
```
# Updates the environment variables for a Lambda function.
# @param function_name: The name of the function to update.
# @param log_level: The log level of the function.
# @return: Data about the update, including the status.
def update_function_configuration(function_name, log_level)
@lambda_client.update_function_configuration({
function_name: function_name,
environment: {
variables: {
'LOG_LEVEL' => log_level
}
}
})
@lambda_client.wait_until(:function_updated_v2, { function_name: function_name }) do |w|
w.max_attempts = 5
w.delay = 5
end
rescue Aws::Lambda::Errors::ServiceException => e
@logger.error("There was an error updating configurations for #{function_name}:\n #{e.message}")
rescue Aws::Waiters::Errors::WaiterFailed => e
@logger.error("Failed waiting for #{function_name} to activate:\n #{e.message}")
end
```
使用包含不同代码的不同部署程序包更新 Lambda 函数的代码。
```
# Updates the code for a Lambda function by submitting a .zip archive that contains
# the code for the function.
#
# @param function_name: The name of the function to update.
# @param deployment_package: The function code to update, packaged as bytes in
# .zip format.
# @return: Data about the update, including the status.
def update_function_code(function_name, deployment_package)
@lambda_client.update_function_code(
function_name: function_name,
zip_file: deployment_package
)
@lambda_client.wait_until(:function_updated_v2, { function_name: function_name }) do |w|
w.max_attempts = 5
w.delay = 5
end
rescue Aws::Lambda::Errors::ServiceException => e
@logger.error("There was an error updating function code for: #{function_name}:\n #{e.message}")
nil
rescue Aws::Waiters::Errors::WaiterFailed => e
@logger.error("Failed waiting for #{function_name} to update:\n #{e.message}")
end
```
使用内置分页工具列出所有现有的 Lambda 函数。
```
# Lists the Lambda functions for the current account.
def list_functions
functions = []
@lambda_client.list_functions.each do |response|
response['functions'].each do |function|
functions.append(function['function_name'])
end
end
functions
rescue Aws::Lambda::Errors::ServiceException => e
@logger.error("There was an error listing functions:\n #{e.message}")
end
```
删除特定的 Lambda 函数。
```
# Deletes a Lambda function.
# @param function_name: The name of the function to delete.
def delete_function(function_name)
print "Deleting function: #{function_name}..."
@lambda_client.delete_function(
function_name: function_name
)
print 'Done!'.green
rescue Aws::Lambda::Errors::ServiceException => e
@logger.error("There was an error deleting #{function_name}:\n #{e.message}")
end
```
+ 有关 API 详细信息，请参阅《适用于 Ruby 的 AWS SDK API Reference》**中的以下主题。
+ [CreateFunction](https://docs.aws.amazon.com/goto/SdkForRubyV3/lambda-2015-03-31/CreateFunction)
+ [DeleteFunction](https://docs.aws.amazon.com/goto/SdkForRubyV3/lambda-2015-03-31/DeleteFunction)
+ [GetFunction](https://docs.aws.amazon.com/goto/SdkForRubyV3/lambda-2015-03-31/GetFunction)
+ [Invoke](https://docs.aws.amazon.com/goto/SdkForRubyV3/lambda-2015-03-31/Invoke)
+ [ListFunctions](https://docs.aws.amazon.com/goto/SdkForRubyV3/lambda-2015-03-31/ListFunctions)
+ [UpdateFunctionCode](https://docs.aws.amazon.com/goto/SdkForRubyV3/lambda-2015-03-31/UpdateFunctionCode)
+ [UpdateFunctionConfiguration](https://docs.aws.amazon.com/goto/SdkForRubyV3/lambda-2015-03-31/UpdateFunctionConfiguration)
## 操作
### `CreateFunction`
以下代码示例演示了如何使用 `CreateFunction`。
**适用于 Ruby 的 SDK**
还有更多相关信息 GitHub。在 [AWS 代码示例存储库](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/ruby/example_code/lambda#code-examples)中查找完整示例，了解如何进行设置和运行。
```
class LambdaWrapper
attr_accessor :lambda_client, :cloudwatch_client, :iam_client
def initialize
@lambda_client = Aws::Lambda::Client.new
@cloudwatch_client = Aws::CloudWatchLogs::Client.new(region: 'us-east-1')
@iam_client = Aws::IAM::Client.new(region: 'us-east-1')
@logger = Logger.new($stdout)
@logger.level = Logger::WARN
end
# Deploys a Lambda function.
#
# @param function_name: The name of the Lambda function.
# @param handler_name: The fully qualified name of the handler function.
# @param role_arn: The IAM role to use for the function.
# @param deployment_package: The deployment package that contains the function code in .zip format.
# @return: The Amazon Resource Name (ARN) of the newly created function.
def create_function(function_name, handler_name, role_arn, deployment_package)
response = @lambda_client.create_function({
role: role_arn.to_s,
function_name: function_name,
handler: handler_name,
runtime: 'ruby2.7',
code: {
zip_file: deployment_package
},
environment: {
variables: {
'LOG_LEVEL' => 'info'
}
}
})
@lambda_client.wait_until(:function_active_v2, { function_name: function_name }) do |w|
w.max_attempts = 5
w.delay = 5
end
response
rescue Aws::Lambda::Errors::ServiceException => e
@logger.error("There was an error creating #{function_name}:\n #{e.message}")
rescue Aws::Waiters::Errors::WaiterFailed => e
@logger.error("Failed waiting for #{function_name} to activate:\n #{e.message}")
end
```
+ 有关 API 的详细信息，请参阅 *适用于 Ruby 的 AWS SDK API 参考[CreateFunction](https://docs.aws.amazon.com/goto/SdkForRubyV3/lambda-2015-03-31/CreateFunction)*中的。
### `DeleteFunction`
以下代码示例演示了如何使用 `DeleteFunction`。
**适用于 Ruby 的 SDK**
还有更多相关信息 GitHub。在 [AWS 代码示例存储库](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/ruby/example_code/lambda#code-examples)中查找完整示例，了解如何进行设置和运行。
```
class LambdaWrapper
attr_accessor :lambda_client, :cloudwatch_client, :iam_client
def initialize
@lambda_client = Aws::Lambda::Client.new
@cloudwatch_client = Aws::CloudWatchLogs::Client.new(region: 'us-east-1')
@iam_client = Aws::IAM::Client.new(region: 'us-east-1')
@logger = Logger.new($stdout)
@logger.level = Logger::WARN
end
# Deletes a Lambda function.
# @param function_name: The name of the function to delete.
def delete_function(function_name)
print "Deleting function: #{function_name}..."
@lambda_client.delete_function(
function_name: function_name
)
print 'Done!'.green
rescue Aws::Lambda::Errors::ServiceException => e
@logger.error("There was an error deleting #{function_name}:\n #{e.message}")
end
```
+ 有关 API 的详细信息，请参阅 *适用于 Ruby 的 AWS SDK API 参考[DeleteFunction](https://docs.aws.amazon.com/goto/SdkForRubyV3/lambda-2015-03-31/DeleteFunction)*中的。
### `GetFunction`
以下代码示例演示了如何使用 `GetFunction`。
**适用于 Ruby 的 SDK**
还有更多相关信息 GitHub。在 [AWS 代码示例存储库](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/ruby/example_code/lambda#code-examples)中查找完整示例，了解如何进行设置和运行。
```
class LambdaWrapper
attr_accessor :lambda_client, :cloudwatch_client, :iam_client
def initialize
@lambda_client = Aws::Lambda::Client.new
@cloudwatch_client = Aws::CloudWatchLogs::Client.new(region: 'us-east-1')
@iam_client = Aws::IAM::Client.new(region: 'us-east-1')
@logger = Logger.new($stdout)
@logger.level = Logger::WARN
end
# Gets data about a Lambda function.
#
# @param function_name: The name of the function.
# @return response: The function data, or nil if no such function exists.
def get_function(function_name)
@lambda_client.get_function(
{
function_name: function_name
}
)
rescue Aws::Lambda::Errors::ResourceNotFoundException => e
@logger.debug("Could not find function: #{function_name}:\n #{e.message}")
nil
end
```
+ 有关 API 的详细信息，请参阅 *适用于 Ruby 的 AWS SDK API 参考[GetFunction](https://docs.aws.amazon.com/goto/SdkForRubyV3/lambda-2015-03-31/GetFunction)*中的。
### `Invoke`
以下代码示例演示了如何使用 `Invoke`。
**适用于 Ruby 的 SDK**
还有更多相关信息 GitHub。在 [AWS 代码示例存储库](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/ruby/example_code/lambda#code-examples)中查找完整示例，了解如何进行设置和运行。
```
class LambdaWrapper
attr_accessor :lambda_client, :cloudwatch_client, :iam_client
def initialize
@lambda_client = Aws::Lambda::Client.new
@cloudwatch_client = Aws::CloudWatchLogs::Client.new(region: 'us-east-1')
@iam_client = Aws::IAM::Client.new(region: 'us-east-1')
@logger = Logger.new($stdout)
@logger.level = Logger::WARN
end
# Invokes a Lambda function.
# @param function_name [String] The name of the function to invoke.
# @param payload [nil] Payload containing runtime parameters.
# @return [Object] The response from the function invocation.
def invoke_function(function_name, payload = nil)
params = { function_name: function_name }
params[:payload] = payload unless payload.nil?
@lambda_client.invoke(params)
rescue Aws::Lambda::Errors::ServiceException => e
@logger.error("There was an error executing #{function_name}:\n #{e.message}")
end
```
+ 有关 API 详细信息，请参阅《适用于 Ruby 的 AWS SDK API Reference》**中的 [Invoke](https://docs.aws.amazon.com/goto/SdkForRubyV3/lambda-2015-03-31/Invoke)。
### `ListFunctions`
以下代码示例演示了如何使用 `ListFunctions`。
**适用于 Ruby 的 SDK**
还有更多相关信息 GitHub。在 [AWS 代码示例存储库](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/ruby/example_code/lambda#code-examples)中查找完整示例，了解如何进行设置和运行。
```
class LambdaWrapper
attr_accessor :lambda_client, :cloudwatch_client, :iam_client
def initialize
@lambda_client = Aws::Lambda::Client.new
@cloudwatch_client = Aws::CloudWatchLogs::Client.new(region: 'us-east-1')
@iam_client = Aws::IAM::Client.new(region: 'us-east-1')
@logger = Logger.new($stdout)
@logger.level = Logger::WARN
end
# Lists the Lambda functions for the current account.
def list_functions
functions = []
@lambda_client.list_functions.each do |response|
response['functions'].each do |function|
functions.append(function['function_name'])
end
end
functions
rescue Aws::Lambda::Errors::ServiceException => e
@logger.error("There was an error listing functions:\n #{e.message}")
end
```
+ 有关 API 的详细信息，请参阅 *适用于 Ruby 的 AWS SDK API 参考[ListFunctions](https://docs.aws.amazon.com/goto/SdkForRubyV3/lambda-2015-03-31/ListFunctions)*中的。
### `UpdateFunctionCode`
以下代码示例演示了如何使用 `UpdateFunctionCode`。
**适用于 Ruby 的 SDK**
还有更多相关信息 GitHub。在 [AWS 代码示例存储库](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/ruby/example_code/lambda#code-examples)中查找完整示例，了解如何进行设置和运行。
```
class LambdaWrapper
attr_accessor :lambda_client, :cloudwatch_client, :iam_client
def initialize
@lambda_client = Aws::Lambda::Client.new
@cloudwatch_client = Aws::CloudWatchLogs::Client.new(region: 'us-east-1')
@iam_client = Aws::IAM::Client.new(region: 'us-east-1')
@logger = Logger.new($stdout)
@logger.level = Logger::WARN
end
# Updates the code for a Lambda function by submitting a .zip archive that contains
# the code for the function.
#
# @param function_name: The name of the function to update.
# @param deployment_package: The function code to update, packaged as bytes in
# .zip format.
# @return: Data about the update, including the status.
def update_function_code(function_name, deployment_package)
@lambda_client.update_function_code(
function_name: function_name,
zip_file: deployment_package
)
@lambda_client.wait_until(:function_updated_v2, { function_name: function_name }) do |w|
w.max_attempts = 5
w.delay = 5
end
rescue Aws::Lambda::Errors::ServiceException => e
@logger.error("There was an error updating function code for: #{function_name}:\n #{e.message}")
nil
rescue Aws::Waiters::Errors::WaiterFailed => e
@logger.error("Failed waiting for #{function_name} to update:\n #{e.message}")
end
```
+ 有关 API 的详细信息，请参阅 *适用于 Ruby 的 AWS SDK API 参考[UpdateFunctionCode](https://docs.aws.amazon.com/goto/SdkForRubyV3/lambda-2015-03-31/UpdateFunctionCode)*中的。
### `UpdateFunctionConfiguration`
以下代码示例演示了如何使用 `UpdateFunctionConfiguration`。
**适用于 Ruby 的 SDK**
还有更多相关信息 GitHub。在 [AWS 代码示例存储库](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/ruby/example_code/lambda#code-examples)中查找完整示例，了解如何进行设置和运行。
```
class LambdaWrapper
attr_accessor :lambda_client, :cloudwatch_client, :iam_client
def initialize
@lambda_client = Aws::Lambda::Client.new
@cloudwatch_client = Aws::CloudWatchLogs::Client.new(region: 'us-east-1')
@iam_client = Aws::IAM::Client.new(region: 'us-east-1')
@logger = Logger.new($stdout)
@logger.level = Logger::WARN
end
# Updates the environment variables for a Lambda function.
# @param function_name: The name of the function to update.
# @param log_level: The log level of the function.
# @return: Data about the update, including the status.
def update_function_configuration(function_name, log_level)
@lambda_client.update_function_configuration({
function_name: function_name,
environment: {
variables: {
'LOG_LEVEL' => log_level
}
}
})
@lambda_client.wait_until(:function_updated_v2, { function_name: function_name }) do |w|
w.max_attempts = 5
w.delay = 5
end
rescue Aws::Lambda::Errors::ServiceException => e
@logger.error("There was an error updating configurations for #{function_name}:\n #{e.message}")
rescue Aws::Waiters::Errors::WaiterFailed => e
@logger.error("Failed waiting for #{function_name} to activate:\n #{e.message}")
end
```
+ 有关 API 的详细信息，请参阅 *适用于 Ruby 的 AWS SDK API 参考[UpdateFunctionConfiguration](https://docs.aws.amazon.com/goto/SdkForRubyV3/lambda-2015-03-31/UpdateFunctionConfiguration)*中的。
## 场景
### 创建用于分析客户反馈的应用程序
以下代码示例说明如何创建应用程序来分析客户意见卡、翻译其母语、确定其情绪并根据译后的文本生成音频文件。
**适用于 Ruby 的 SDK**
此示例应用程序可分析并存储客户反馈卡。具体来说，它满足了纽约市一家虚构酒店的需求。酒店以实体意见卡的形式收集来自不同语种的客人的反馈。该反馈通过 Web 客户端上传到应用程序中。意见卡图片上传后，将执行以下步骤：
+ 使用 Amazon Textract 从图片中提取文本。
+ Amazon Comprehend 确定所提取文本的情绪及其语言。
+ 使用 Amazon Translate 将所提取文本翻译为英语。
+ Amazon Polly 根据所提取文本合成音频文件。
完整的应用程序可使用 AWS CDK 进行部署。有关源代码和部署说明，请参阅中的项目[ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/ruby/cross_service_examples/feedback_sentiment_analyzer)。
**本示例中使用的服务**
+ Amazon Comprehend
+ Lambda
+ Amazon Polly
+ Amazon Textract
+ Amazon Translate
## 无服务器示例
### 使用 Lambda 函数连接到 Amazon RDS 数据库
以下代码示例显示如何实现连接到 RDS 数据库的 Lambda 函数。该函数发出一个简单的数据库请求并返回结果。
**适用于 Ruby 的 SDK**
还有更多相关信息 GitHub。在[无服务器示例](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-connect-rds-iam)存储库中查找完整示例，并了解如何进行设置和运行。
在 Lambda 函数中使用 Ruby 连接到 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
```
### 通过 Kinesis 触发器调用 Lambda 函数
以下代码示例展示了如何实现一个 Lambda 函数，该函数接收因接收来自 Kinesis 流的记录而触发的事件。该函数检索 Kinesis 有效负载，将 Base64 解码，并记录下记录内容。
**适用于 Ruby 的 SDK**
还有更多相关信息 GitHub。在[无服务器示例](https://github.com/aws-samples/serverless-snippets/tree/main/integration-kinesis-to-lambda)存储库中查找完整示例，并了解如何进行设置和运行。
通过 Ruby 将 Kinesis 事件与 Lambda 结合使用。
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
require 'aws-sdk'
def lambda_handler(event:, context:)
event['Records'].each do |record|
begin
puts "Processed Kinesis Event - EventID: #{record['eventID']}"
record_data = get_record_data_async(record['kinesis'])
puts "Record Data: #{record_data}"
# TODO: Do interesting work based on the new data
rescue => err
$stderr.puts "An error occurred #{err}"
raise err
end
end
puts "Successfully processed #{event['Records'].length} records."
end
def get_record_data_async(payload)
data = Base64.decode64(payload['data']).force_encoding('UTF-8')
# Placeholder for actual async work
# You can use Ruby's asynchronous programming tools like async/await or fibers here.
return data
end
```
### 通过 DynamoDB 触发器调用 Lambda 函数
以下代码示例演示如何实现一个 Lambda 函数，该函数接收通过接收来自 DynamoDB 流的记录而触发的事件。该函数检索 DynamoDB 有效负载，并记录下记录内容。
**适用于 Ruby 的 SDK**
还有更多相关信息 GitHub。在[无服务器示例](https://github.com/aws-samples/serverless-snippets/tree/main/integration-ddb-to-lambda)存储库中查找完整示例，并了解如何进行设置和运行。
通过 Ruby 将 DynamoDB 事件与 Lambda 结合使用。
```
def lambda_handler(event:, context:)
return 'received empty event' if event['Records'].empty?
event['Records'].each do |record|
log_dynamodb_record(record)
end
"Records processed: #{event['Records'].length}"
end
def log_dynamodb_record(record)
puts record['eventID']
puts record['eventName']
puts "DynamoDB Record: #{JSON.generate(record['dynamodb'])}"
end
```
### 通过 Amazon DocumentDB 触发器调用 Lambda 函数
以下代码示例演示如何实现一个 Lambda 函数，该函数接收通过接收来自 DocumentDB 更改流的记录而触发的事件。该函数检索 DocumentDB 有效负载，并记录下记录内容。
**适用于 Ruby 的 SDK**
还有更多相关信息 GitHub。在[无服务器示例](https://github.com/aws-samples/serverless-snippets/tree/main/integration-docdb-to-lambda)存储库中查找完整示例，并了解如何进行设置和运行。
使用 Ruby 将 Amazon DocumentDB 事件与 Lambda 结合使用。
```
require 'json'
def lambda_handler(event:, context:)
event['events'].each do |record|
log_document_db_event(record)
end
'OK'
end
def log_document_db_event(record)
event_data = record['event'] || {}
operation_type = event_data['operationType'] || 'Unknown'
db = event_data.dig('ns', 'db') || 'Unknown'
collection = event_data.dig('ns', 'coll') || 'Unknown'
full_document = event_data['fullDocument'] || {}
puts "Operation type: #{operation_type}"
puts "db: #{db}"
puts "collection: #{collection}"
puts "Full document: #{JSON.pretty_generate(full_document)}"
end
```
### 通过 Amazon MSK 触发器调用 Lambda 函数
以下代码示例演示如何实现一个 Lambda 函数，该函数接收通过接收来自 Amazon MSK 集群的记录而触发的事件。该函数检索 MSK 有效负载，并记录下记录内容。
**适用于 Ruby 的 SDK**
还有更多相关信息 GitHub。在[无服务器示例](https://github.com/aws-samples/serverless-snippets/tree/main/integration-msk-to-lambda)存储库中查找完整示例，并了解如何进行设置和运行。
通过 Ruby 将 Amazon MSK 事件与 Lambda 结合使用。
```
require 'base64'
def lambda_handler(event:, context:)
# Iterate through keys
event['records'].each do |key, records|
puts "Key: #{key}"
# Iterate through records
records.each do |record|
puts "Record: #{record}"
# Decode base64
msg = Base64.decode64(record['value'])
puts "Message: #{msg}"
end
end
end
```
### 通过 Amazon S3 触发器调用 Lambda 函数
以下代码示例展示了如何实现一个 Lambda 函数，该函数接收通过将对象上传到 S3 桶而触发的事件。该函数从事件参数中检索 S3 存储桶名称和对象密钥，并调用 Amazon S3 API 来检索和记录对象的内容类型。
**适用于 Ruby 的 SDK**
还有更多相关信息 GitHub。在[无服务器示例](https://github.com/aws-samples/serverless-snippets/tree/main/integration-s3-to-lambda)存储库中查找完整示例，并了解如何进行设置和运行。
通过 Ruby 将 S3 事件与 Lambda 结合使用。
```
require 'json'
require 'uri'
require 'aws-sdk'
puts 'Loading function'
def lambda_handler(event:, context:)
s3 = Aws::S3::Client.new(region: 'region') # Your AWS region
# puts "Received event: #{JSON.dump(event)}"
# Get the object from the event and show its content type
bucket = event['Records'][0]['s3']['bucket']['name']
key = URI.decode_www_form_component(event['Records'][0]['s3']['object']['key'], Encoding::UTF_8)
begin
response = s3.get_object(bucket: bucket, key: key)
puts "CONTENT TYPE: #{response.content_type}"
return response.content_type
rescue StandardError => e
puts e.message
puts "Error getting object #{key} from bucket #{bucket}. Make sure they exist and your bucket is in the same region as this function."
raise e
end
end
```
### 通过 Amazon SNS 触发器调用 Lambda 函数
以下代码示例展示了如何实现一个 Lambda 函数，该函数接收因接收来自 SNS 主题的消息而触发的事件。该函数从事件参数检索消息并记录每条消息的内容。
**适用于 Ruby 的 SDK**
还有更多相关信息 GitHub。在[无服务器示例](https://github.com/aws-samples/serverless-snippets/tree/main/integration-sns-to-lambda)存储库中查找完整示例，并了解如何进行设置和运行。
通过 Ruby 将 SNS 事件与 Lambda 结合使用。
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
def lambda_handler(event:, context:)
event['Records'].map { |record| process_message(record) }
end
def process_message(record)
message = record['Sns']['Message']
puts("Processing message: #{message}")
rescue StandardError => e
puts("Error processing message: #{e}")
raise
end
```
### 通过 Amazon SQS 触发器调用 Lambda 函数
以下代码示例展示了如何实现一个 Lambda 函数，该函数接收因接收来自 SNS 队列的消息而触发的事件。该函数从事件参数检索消息并记录每条消息的内容。
**适用于 Ruby 的 SDK**
还有更多相关信息 GitHub。在[无服务器示例](https://github.com/aws-samples/serverless-snippets/tree/main/integration-sqs-to-lambda)存储库中查找完整示例，并了解如何进行设置和运行。
使用 Ruby 将 SQS 事件与 Lambda 结合使用。
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
def lambda_handler(event:, context:)
event['Records'].each do |message|
process_message(message)
end
puts "done"
end
def process_message(message)
begin
puts "Processed message #{message['body']}"
# TODO: Do interesting work based on the new message
rescue StandardError => err
puts "An error occurred"
raise err
end
end
```
### 通过 Kinesis 触发器报告 Lambda 函数批处理项目失败
以下代码示例展示了如何为接收来自 Kinesis 流的事件的 Lambda 函数实现部分批处理响应。该函数在响应中报告批处理项目失败，并指示 Lambda 稍后重试这些消息。
**适用于 Ruby 的 SDK**
还有更多相关信息 GitHub。在[无服务器示例](https://github.com/aws-samples/serverless-snippets/tree/main/integration-kinesis-to-lambda-with-batch-item-handling)存储库中查找完整示例，并了解如何进行设置和运行。
报告通过 Ruby 进行 Lambda Kinesis 批处理项目失败。
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
require 'aws-sdk'
def lambda_handler(event:, context:)
batch_item_failures = []
event['Records'].each do |record|
begin
puts "Processed Kinesis Event - EventID: #{record['eventID']}"
record_data = get_record_data_async(record['kinesis'])
puts "Record Data: #{record_data}"
# TODO: Do interesting work based on the new data
rescue StandardError => err
puts "An error occurred #{err}"
# Since we are working with streams, we can return the failed item immediately.
# Lambda will immediately begin to retry processing from this failed item onwards.
return { batchItemFailures: [{ itemIdentifier: record['kinesis']['sequenceNumber'] }] }
end
end
puts "Successfully processed #{event['Records'].length} records."
{ batchItemFailures: batch_item_failures }
end
def get_record_data_async(payload)
data = Base64.decode64(payload['data']).force_encoding('utf-8')
# Placeholder for actual async work
sleep(1)
data
end
```
### 通过 DynamoDB 触发器报告 Lambda 函数批处理项目失败
以下代码示例演示如何为接收来自 DynamoDB 流的事件的 Lambda 函数实现部分批处理响应。该函数在响应中报告批处理项目失败，并指示 Lambda 稍后重试这些消息。
**适用于 Ruby 的 SDK**
还有更多相关信息 GitHub。在[无服务器示例](https://github.com/aws-samples/serverless-snippets/tree/main/integration-ddb-to-lambda-with-batch-item-handling)存储库中查找完整示例，并了解如何进行设置和运行。
报告使用 Ruby 通过 Lambda 进行 DynamoDB 批处理项目失败。
```
def lambda_handler(event:, context:)
records = event["Records"]
cur_record_sequence_number = ""
records.each do |record|
begin
# Process your record
cur_record_sequence_number = record["dynamodb"]["SequenceNumber"]
rescue StandardError => e
# Return failed record's sequence number
return {"batchItemFailures" => [{"itemIdentifier" => cur_record_sequence_number}]}
end
end
{"batchItemFailures" => []}
end
```
### 报告使用 Amazon SQS 触发器进行 Lambda 函数批处理项目失败
以下代码示例展示了如何为接收来自 SQS 队列的事件的 Lambda 函数实现部分批处理响应。该函数在响应中报告批处理项目失败，并指示 Lambda 稍后重试这些消息。
**适用于 Ruby 的 SDK**
还有更多相关信息 GitHub。在[无服务器示例](https://github.com/aws-samples/serverless-snippets/tree/main/integration-sqs-to-lambda-with-batch-item-handling)存储库中查找完整示例，并了解如何进行设置和运行。
报告使用 Ruby 进行 Lambda SQS 批处理项目失败。
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
require 'json'
def lambda_handler(event:, context:)
if event
batch_item_failures = []
sqs_batch_response = {}
event["Records"].each do |record|
begin
# process message
rescue StandardError => e
batch_item_failures << {"itemIdentifier" => record['messageId']}
end
end
sqs_batch_response["batchItemFailures"] = batch_item_failures
return sqs_batch_response
end
end
```