Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Contoh Lambda menggunakan SDK for Ruby
Contoh kode berikut menunjukkan cara melakukan tindakan dan mengimplementasikan skenario umum dengan menggunakan Lambda AWS SDK untuk Ruby with.
*Dasar-dasar* adalah contoh kode yang menunjukkan kepada Anda bagaimana melakukan operasi penting dalam suatu layanan.
*Tindakan* merupakan kutipan kode dari program yang lebih besar dan harus dijalankan dalam konteks. Sementara tindakan menunjukkan cara memanggil fungsi layanan individual, Anda dapat melihat tindakan dalam konteks dalam skenario terkait.
*Skenario* adalah contoh kode yang menunjukkan kepada Anda bagaimana menyelesaikan tugas tertentu dengan memanggil beberapa fungsi dalam layanan atau dikombinasikan dengan yang lain Layanan AWS.
Setiap contoh menyertakan tautan ke kode sumber lengkap, di mana Anda dapat menemukan instruksi tentang cara mengatur dan menjalankan kode dalam konteks.
**Topics**
+ [Memulai](#get_started)
+ [Hal-hal mendasar](#basics)
+ [Tindakan](#actions)
+ [Skenario](#scenarios)
+ [Contoh nirserver](#serverless_examples)
## Memulai
### Halo Lambda
Contoh kode berikut menunjukkan cara memulai menggunakan Lambda.
**SDK untuk Ruby**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode 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
```
+ Untuk detail API, lihat [ListFunctions](https://docs.aws.amazon.com/goto/SdkForRubyV3/lambda-2015-03-31/ListFunctions)di *Referensi AWS SDK untuk Ruby API*.
## Hal-hal mendasar
### Pelajari dasar-dasarnya
Contoh kode berikut ini menunjukkan cara untuk melakukan:
+ Buat peran IAM dan fungsi Lambda, lalu unggah kode handler.
+ Panggil fungsi dengan satu parameter dan dapatkan hasil.
+ Perbarui kode fungsi dan konfigurasikan dengan variabel lingkungan.
+ Panggil fungsi dengan parameter baru dan dapatkan hasil. Tampilkan log eksekusi yang dikembalikan.
+ Buat daftar fungsi untuk akun Anda, lalu bersihkan sumber daya.
Untuk informasi selengkapnya, lihat [Membuat fungsi Lambda dengan konsol.](https://docs.aws.amazon.com/lambda/latest/dg/getting-started-create-function.html)
**SDK untuk Ruby**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/ruby/example_code/lambda#code-examples).
Siapkan izin IAM prasyarat untuk fungsi Lambda yang mampu menulis log.
```
# 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
```
Tentukan handler Lambda yang menambah angka yang disediakan sebagai parameter pemanggilan.
```
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
```
Zip fungsi Lambda Anda ke dalam paket penerapan.
```
# 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
```
Buat fungsi Lambda baru.
```
# 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
```
Panggil fungsi Lambda Anda dengan parameter runtime opsional.
```
# 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
```
Perbarui konfigurasi fungsi Lambda Anda untuk menyuntikkan variabel lingkungan baru.
```
# 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
```
Perbarui kode fungsi Lambda Anda dengan paket penerapan berbeda yang berisi kode berbeda.
```
# 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
```
Daftar semua fungsi Lambda yang ada menggunakan paginator bawaan.
```
# 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
```
Hapus fungsi Lambda tertentu.
```
# 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
```
+ Untuk detail API, lihat topik berikut di *Referensi API AWS SDK untuk Ruby *.
+ [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)
+ [Memohon](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)
## Tindakan
### `CreateFunction`
Contoh kode berikut menunjukkan cara menggunakan`CreateFunction`.
**SDK untuk Ruby**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode 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
```
+ Untuk detail API, lihat [CreateFunction](https://docs.aws.amazon.com/goto/SdkForRubyV3/lambda-2015-03-31/CreateFunction)di *Referensi AWS SDK untuk Ruby API*.
### `DeleteFunction`
Contoh kode berikut menunjukkan cara menggunakan`DeleteFunction`.
**SDK untuk Ruby**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode 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
```
+ Untuk detail API, lihat [DeleteFunction](https://docs.aws.amazon.com/goto/SdkForRubyV3/lambda-2015-03-31/DeleteFunction)di *Referensi AWS SDK untuk Ruby API*.
### `GetFunction`
Contoh kode berikut menunjukkan cara menggunakan`GetFunction`.
**SDK untuk Ruby**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode 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
```
+ Untuk detail API, lihat [GetFunction](https://docs.aws.amazon.com/goto/SdkForRubyV3/lambda-2015-03-31/GetFunction)di *Referensi AWS SDK untuk Ruby API*.
### `Invoke`
Contoh kode berikut menunjukkan cara menggunakan`Invoke`.
**SDK untuk Ruby**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode 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
```
+ Untuk detail API, lihat [Memanggil di Referensi AWS SDK untuk Ruby](https://docs.aws.amazon.com/goto/SdkForRubyV3/lambda-2015-03-31/Invoke) *API*.
### `ListFunctions`
Contoh kode berikut menunjukkan cara menggunakan`ListFunctions`.
**SDK untuk Ruby**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode 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
```
+ Untuk detail API, lihat [ListFunctions](https://docs.aws.amazon.com/goto/SdkForRubyV3/lambda-2015-03-31/ListFunctions)di *Referensi AWS SDK untuk Ruby API*.
### `UpdateFunctionCode`
Contoh kode berikut menunjukkan cara menggunakan`UpdateFunctionCode`.
**SDK untuk Ruby**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode 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
```
+ Untuk detail API, lihat [UpdateFunctionCode](https://docs.aws.amazon.com/goto/SdkForRubyV3/lambda-2015-03-31/UpdateFunctionCode)di *Referensi AWS SDK untuk Ruby API*.
### `UpdateFunctionConfiguration`
Contoh kode berikut menunjukkan cara menggunakan`UpdateFunctionConfiguration`.
**SDK untuk Ruby**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode 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
```
+ Untuk detail API, lihat [UpdateFunctionConfiguration](https://docs.aws.amazon.com/goto/SdkForRubyV3/lambda-2015-03-31/UpdateFunctionConfiguration)di *Referensi AWS SDK untuk Ruby API*.
## Skenario
### Buat aplikasi untuk menganalisis umpan balik pelanggan
Contoh kode berikut menunjukkan cara membuat aplikasi yang menganalisis kartu komentar pelanggan, menerjemahkannya dari bahasa aslinya, menentukan sentimen mereka, dan menghasilkan file audio dari teks yang diterjemahkan.
**SDK untuk Ruby**
Aplikasi contoh ini menganalisis dan menyimpan kartu umpan balik pelanggan. Secara khusus, ini memenuhi kebutuhan hotel fiktif di New York City. Hotel menerima umpan balik dari para tamu dalam berbagai bahasa dalam bentuk kartu komentar fisik. Umpan balik itu diunggah ke aplikasi melalui klien web. Setelah gambar kartu komentar diunggah, langkah-langkah berikut terjadi:
+ Teks diekstraksi dari gambar menggunakan Amazon Textract.
+ Amazon Comprehend menentukan sentimen teks yang diekstraksi dan bahasanya.
+ Teks yang diekstraksi diterjemahkan ke bahasa Inggris menggunakan Amazon Translate.
+ Amazon Polly mensintesis file audio dari teks yang diekstraksi.
Aplikasi lengkap dapat digunakan dengan. AWS CDK Untuk kode sumber dan petunjuk penerapan, lihat proyek di [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/ruby/cross_service_examples/feedback_sentiment_analyzer).
**Layanan yang digunakan dalam contoh ini**
+ Amazon Comprehend
+ Lambda
+ Amazon Polly
+ Amazon Textract
+ Amazon Translate
## Contoh nirserver
### Menghubungkan ke database Amazon RDS dalam fungsi Lambda
Contoh kode berikut menunjukkan bagaimana menerapkan fungsi Lambda yang menghubungkan ke database RDS. Fungsi membuat permintaan database sederhana dan mengembalikan hasilnya.
**SDK untuk Ruby**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di repositori [contoh Nirserver](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-connect-rds-iam).
Menghubungkan ke database Amazon RDS dalam fungsi Lambda menggunakan 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
```
### Memanggil fungsi Lambda dari pemicu Kinesis
Contoh kode berikut menunjukkan bagaimana menerapkan fungsi Lambda yang menerima peristiwa yang dipicu oleh menerima catatan dari aliran Kinesis. Fungsi mengambil payload Kinesis, mendekode dari Base64, dan mencatat konten rekaman.
**SDK untuk Ruby**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di repositori [contoh Nirserver](https://github.com/aws-samples/serverless-snippets/tree/main/integration-kinesis-to-lambda).
Mengkonsumsi acara Kinesis dengan Lambda menggunakan Ruby.
```
# 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
```
### Memanggil fungsi Lambda dari pemicu DynamoDB
Contoh kode berikut menunjukkan bagaimana menerapkan fungsi Lambda yang menerima peristiwa yang dipicu oleh menerima catatan dari aliran DynamoDB. Fungsi mengambil payload DynamoDB dan mencatat isi catatan.
**SDK untuk Ruby**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di repositori [contoh Nirserver](https://github.com/aws-samples/serverless-snippets/tree/main/integration-ddb-to-lambda).
Mengkonsumsi acara DynamoDB dengan Lambda menggunakan Ruby.
```
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
```
### Memanggil fungsi Lambda dari pemicu Amazon DocumentDB
Contoh kode berikut menunjukkan cara menerapkan fungsi Lambda yang menerima peristiwa yang dipicu dengan menerima catatan dari aliran perubahan DocumentDB. Fungsi mengambil payload DocumentDB dan mencatat isi catatan.
**SDK untuk Ruby**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di repositori [contoh Nirserver](https://github.com/aws-samples/serverless-snippets/tree/main/integration-docdb-to-lambda).
Mengkonsumsi acara Amazon DocumentDB dengan Lambda menggunakan Ruby.
```
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
```
### Memanggil fungsi Lambda dari pemicu MSK Amazon
Contoh kode berikut menunjukkan cara menerapkan fungsi Lambda yang menerima peristiwa yang dipicu dengan menerima catatan dari kluster MSK Amazon. Fungsi mengambil muatan MSK dan mencatat konten catatan.
**SDK untuk Ruby**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di repositori [contoh Nirserver](https://github.com/aws-samples/serverless-snippets/tree/main/integration-msk-to-lambda).
Mengkonsumsi acara MSK Amazon dengan Lambda menggunakan Ruby.
```
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
```
### Menginvokasi fungsi Lambda dari pemicu Amazon S3
Contoh kode berikut menunjukkan cara mengimplementasikan fungsi Lambda yang menerima peristiwa yang dipicu dengan mengunggah objek ke bucket S3. Fungsi ini mengambil nama bucket S3 dan kunci objek dari parameter peristiwa dan memanggil Amazon S3 API untuk mengambil dan mencatat jenis konten objek.
**SDK untuk Ruby**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di repositori [contoh Nirserver](https://github.com/aws-samples/serverless-snippets/tree/main/integration-s3-to-lambda).
Mengkonsumsi acara S3 dengan Lambda menggunakan Ruby.
```
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
```
### Memanggil fungsi Lambda dari pemicu Amazon SNS
Contoh kode berikut menunjukkan cara menerapkan fungsi Lambda yang menerima peristiwa yang dipicu dengan menerima pesan dari topik SNS. Fungsi mengambil pesan dari parameter peristiwa dan mencatat konten setiap pesan.
**SDK untuk Ruby**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di repositori [contoh Nirserver](https://github.com/aws-samples/serverless-snippets/tree/main/integration-sns-to-lambda).
Mengkonsumsi acara SNS dengan Lambda menggunakan Ruby.
```
# 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
```
### Memanggil fungsi Lambda dari pemicu Amazon SQS
Contoh kode berikut menunjukkan bagaimana menerapkan fungsi Lambda yang menerima peristiwa yang dipicu oleh menerima pesan dari antrian SQS. Fungsi mengambil pesan dari parameter peristiwa dan mencatat konten setiap pesan.
**SDK untuk Ruby**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di repositori [contoh Nirserver](https://github.com/aws-samples/serverless-snippets/tree/main/integration-sqs-to-lambda).
Mengkonsumsi acara SQS dengan Lambda menggunakan Ruby.
```
# 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
```
### Melaporkan kegagalan item batch untuk fungsi Lambda dengan pemicu Kinesis
Contoh kode berikut menunjukkan cara mengimplementasikan respons batch sebagian untuk fungsi Lambda yang menerima peristiwa dari aliran Kinesis. Fungsi melaporkan kegagalan item batch dalam respons, memberi sinyal ke Lambda untuk mencoba lagi pesan tersebut nanti.
**SDK untuk Ruby**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di repositori [contoh Nirserver](https://github.com/aws-samples/serverless-snippets/tree/main/integration-kinesis-to-lambda-with-batch-item-handling).
Melaporkan kegagalan item batch Kinesis dengan Lambda menggunakan Ruby.
```
# 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
```
### Melaporkan kegagalan item batch untuk fungsi Lambda dengan pemicu DynamoDB
Contoh kode berikut menunjukkan cara mengimplementasikan respons batch sebagian untuk fungsi Lambda yang menerima peristiwa dari aliran DynamoDB. Fungsi melaporkan kegagalan item batch dalam respons, memberi sinyal ke Lambda untuk mencoba lagi pesan tersebut nanti.
**SDK untuk Ruby**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di repositori [contoh Nirserver](https://github.com/aws-samples/serverless-snippets/tree/main/integration-ddb-to-lambda-with-batch-item-handling).
Melaporkan kegagalan item batch DynamoDB dengan Lambda menggunakan Ruby.
```
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
```
### Melaporkan kegagalan item batch untuk fungsi Lambda dengan pemicu Amazon SQS
Contoh kode berikut menunjukkan cara mengimplementasikan respons batch sebagian untuk fungsi Lambda yang menerima peristiwa dari antrian SQS. Fungsi melaporkan kegagalan item batch dalam respons, memberi sinyal ke Lambda untuk mencoba lagi pesan tersebut nanti.
**SDK untuk Ruby**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di repositori [contoh Nirserver](https://github.com/aws-samples/serverless-snippets/tree/main/integration-sqs-to-lambda-with-batch-item-handling).
Melaporkan kegagalan item batch SQS dengan Lambda menggunakan Ruby.
```
# 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
```