Doc AWS SDK Examples GitHub リポジトリには、他にも SDK の例があります。 [AWS](https://github.com/awsdocs/aws-doc-sdk-examples)
翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。
# SDK for Go V2 を使用した Amazon RDS の例
次のコード例は、Amazon RDS で AWS SDK for Go V2 を使用してアクションを実行し、一般的なシナリオを実装する方法を示しています。
*基本* は、重要なオペレーションをサービス内で実行する方法を示すコード例です。
*アクション*はより大きなプログラムからのコードの抜粋であり、コンテキスト内で実行する必要があります。アクションは個々のサービス機能を呼び出す方法を示していますが、コンテキスト内のアクションは、関連するシナリオで確認できます。
各例には完全なソースコードへのリンクが含まれており、コンテキスト内でコードを設定および実行する方法の手順を確認できます。
**Topics**
+ [はじめに](#get_started)
+ [基本](#basics)
+ [アクション](#actions)
+ [サーバーレスサンプル](#serverless_examples)
## はじめに
### Hello Amazon RDS
次のコード例は、Amazon RDS の使用を開始する方法を示しています。
**SDK for Go V2**
GitHub には、その他のリソースもあります。用例一覧を検索し、[AWS コード例リポジトリ](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/rds#code-examples)での設定と実行の方法を確認してください。
```
package main
import (
"context"
"fmt"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/aws-sdk-go-v2/service/rds"
)
// main uses the AWS SDK for Go V2 to create an Amazon Relational Database Service (Amazon RDS)
// client and list up to 20 DB instances in your account.
// This example uses the default settings specified in your shared credentials
// and config files.
func main() {
ctx := context.Background()
sdkConfig, err := config.LoadDefaultConfig(ctx)
if err != nil {
fmt.Println("Couldn't load default configuration. Have you set up your AWS account?")
fmt.Println(err)
return
}
rdsClient := rds.NewFromConfig(sdkConfig)
const maxInstances = 20
fmt.Printf("Let's list up to %v DB instances.\n", maxInstances)
output, err := rdsClient.DescribeDBInstances(ctx,
&rds.DescribeDBInstancesInput{MaxRecords: aws.Int32(maxInstances)})
if err != nil {
fmt.Printf("Couldn't list DB instances: %v\n", err)
return
}
if len(output.DBInstances) == 0 {
fmt.Println("No DB instances found.")
} else {
for _, instance := range output.DBInstances {
fmt.Printf("DB instance %v has database %v.\n", *instance.DBInstanceIdentifier,
*instance.DBName)
}
}
}
```
+ API の詳細については、*AWS SDK for Go API リファレンス*の「[DescribeDBInstances](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/rds#Client.DescribeDBInstances)」を参照してください。
## 基本
### 基本を学ぶ
次のコード例は、以下の操作方法を示しています。
+ カスタム DB パラメータグループを作成し、パラメータ値を設定します。
+ パラメータグループを使用するように設定した DB インスタンスを作成します。DB インスタンスにはデータベースも含まれています。
+ インスタンスのスナップショットを取得します。
+ インスタンスとパラメータグループを削除します。
**SDK for Go V2**
GitHub には、その他のリソースもあります。用例一覧を検索し、[AWS コード例リポジトリ](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/rds#code-examples)での設定と実行の方法を確認してください。
コマンドプロンプトからインタラクティブなシナリオを実行します。
```
import (
"context"
"fmt"
"log"
"sort"
"strconv"
"strings"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/rds"
"github.com/aws/aws-sdk-go-v2/service/rds/types"
"github.com/awsdocs/aws-doc-sdk-examples/gov2/demotools"
"github.com/awsdocs/aws-doc-sdk-examples/gov2/rds/actions"
"github.com/google/uuid"
)
// GetStartedInstances is an interactive example that shows you how to use the AWS SDK for Go
// with Amazon Relation Database Service (Amazon RDS) to do the following:
//
// 1. Create a custom DB parameter group and set parameter values.
// 2. Create a DB instance that is configured to use the parameter group. The DB instance
// also contains a database.
// 3. Take a snapshot of the DB instance.
// 4. Delete the DB instance and parameter group.
type GetStartedInstances struct {
sdkConfig aws.Config
instances actions.DbInstances
questioner demotools.IQuestioner
helper IScenarioHelper
isTestRun bool
}
// NewGetStartedInstances constructs a GetStartedInstances instance from a configuration.
// It uses the specified config to get an Amazon RDS
// client and create wrappers for the actions used in the scenario.
func NewGetStartedInstances(sdkConfig aws.Config, questioner demotools.IQuestioner,
helper IScenarioHelper) GetStartedInstances {
rdsClient := rds.NewFromConfig(sdkConfig)
return GetStartedInstances{
sdkConfig: sdkConfig,
instances: actions.DbInstances{RdsClient: rdsClient},
questioner: questioner,
helper: helper,
}
}
// Run runs the interactive scenario.
func (scenario GetStartedInstances) Run(ctx context.Context, dbEngine string, parameterGroupName string,
instanceName string, dbName string) {
defer func() {
if r := recover(); r != nil {
log.Println("Something went wrong with the demo.")
}
}()
log.Println(strings.Repeat("-", 88))
log.Println("Welcome to the Amazon Relational Database Service (Amazon RDS) DB Instance demo.")
log.Println(strings.Repeat("-", 88))
parameterGroup := scenario.CreateParameterGroup(ctx, dbEngine, parameterGroupName)
scenario.SetUserParameters(ctx, parameterGroupName)
instance := scenario.CreateInstance(ctx, instanceName, dbEngine, dbName, parameterGroup)
scenario.DisplayConnection(instance)
scenario.CreateSnapshot(ctx, instance)
scenario.Cleanup(ctx, instance, parameterGroup)
log.Println(strings.Repeat("-", 88))
log.Println("Thanks for watching!")
log.Println(strings.Repeat("-", 88))
}
// CreateParameterGroup shows how to get available engine versions for a specified
// database engine and create a DB parameter group that is compatible with a
// selected engine family.
func (scenario GetStartedInstances) CreateParameterGroup(ctx context.Context, dbEngine string,
parameterGroupName string) *types.DBParameterGroup {
log.Printf("Checking for an existing DB parameter group named %v.\n",
parameterGroupName)
parameterGroup, err := scenario.instances.GetParameterGroup(ctx, parameterGroupName)
if err != nil {
panic(err)
}
if parameterGroup == nil {
log.Printf("Getting available database engine versions for %v.\n", dbEngine)
engineVersions, err := scenario.instances.GetEngineVersions(ctx, dbEngine, "")
if err != nil {
panic(err)
}
familySet := map[string]struct{}{}
for _, family := range engineVersions {
familySet[*family.DBParameterGroupFamily] = struct{}{}
}
var families []string
for family := range familySet {
families = append(families, family)
}
sort.Strings(families)
familyIndex := scenario.questioner.AskChoice("Which family do you want to use?\n", families)
log.Println("Creating a DB parameter group.")
_, err = scenario.instances.CreateParameterGroup(
ctx, parameterGroupName, families[familyIndex], "Example parameter group.")
if err != nil {
panic(err)
}
parameterGroup, err = scenario.instances.GetParameterGroup(ctx, parameterGroupName)
if err != nil {
panic(err)
}
}
log.Printf("Parameter group %v:\n", *parameterGroup.DBParameterGroupFamily)
log.Printf("\tName: %v\n", *parameterGroup.DBParameterGroupName)
log.Printf("\tARN: %v\n", *parameterGroup.DBParameterGroupArn)
log.Printf("\tFamily: %v\n", *parameterGroup.DBParameterGroupFamily)
log.Printf("\tDescription: %v\n", *parameterGroup.Description)
log.Println(strings.Repeat("-", 88))
return parameterGroup
}
// SetUserParameters shows how to get the parameters contained in a custom parameter
// group and update some of the parameter values in the group.
func (scenario GetStartedInstances) SetUserParameters(ctx context.Context, parameterGroupName string) {
log.Println("Let's set some parameter values in your parameter group.")
dbParameters, err := scenario.instances.GetParameters(ctx, parameterGroupName, "")
if err != nil {
panic(err)
}
var updateParams []types.Parameter
for _, dbParam := range dbParameters {
if strings.HasPrefix(*dbParam.ParameterName, "auto_increment") &&
*dbParam.IsModifiable && *dbParam.DataType == "integer" {
log.Printf("The %v parameter is described as:\n\t%v",
*dbParam.ParameterName, *dbParam.Description)
rangeSplit := strings.Split(*dbParam.AllowedValues, "-")
lower, _ := strconv.Atoi(rangeSplit[0])
upper, _ := strconv.Atoi(rangeSplit[1])
newValue := scenario.questioner.AskInt(
fmt.Sprintf("Enter a value between %v and %v:", lower, upper),
demotools.InIntRange{Lower: lower, Upper: upper})
dbParam.ParameterValue = aws.String(strconv.Itoa(newValue))
updateParams = append(updateParams, dbParam)
}
}
err = scenario.instances.UpdateParameters(ctx, parameterGroupName, updateParams)
if err != nil {
panic(err)
}
log.Println("To get a list of parameters that you set previously, specify a source of 'user'.")
userParameters, err := scenario.instances.GetParameters(ctx, parameterGroupName, "user")
if err != nil {
panic(err)
}
log.Println("Here are the parameters you set:")
for _, param := range userParameters {
log.Printf("\t%v: %v\n", *param.ParameterName, *param.ParameterValue)
}
log.Println(strings.Repeat("-", 88))
}
// CreateInstance shows how to create a DB instance that contains a database of a
// specified type. The database is also configured to use a custom DB parameter group.
func (scenario GetStartedInstances) CreateInstance(ctx context.Context, instanceName string, dbEngine string,
dbName string, parameterGroup *types.DBParameterGroup) *types.DBInstance {
log.Println("Checking for an existing DB instance.")
instance, err := scenario.instances.GetInstance(ctx, instanceName)
if err != nil {
panic(err)
}
if instance == nil {
adminUsername := scenario.questioner.Ask(
"Enter an administrator username for the database: ", demotools.NotEmpty{})
adminPassword := scenario.questioner.AskPassword(
"Enter a password for the administrator (at least 8 characters): ", 7)
engineVersions, err := scenario.instances.GetEngineVersions(ctx, dbEngine,
*parameterGroup.DBParameterGroupFamily)
if err != nil {
panic(err)
}
var engineChoices []string
for _, engine := range engineVersions {
engineChoices = append(engineChoices, *engine.EngineVersion)
}
engineIndex := scenario.questioner.AskChoice(
"The available engines for your parameter group are:\n", engineChoices)
engineSelection := engineVersions[engineIndex]
instOpts, err := scenario.instances.GetOrderableInstances(ctx, *engineSelection.Engine,
*engineSelection.EngineVersion)
if err != nil {
panic(err)
}
optSet := map[string]struct{}{}
for _, opt := range instOpts {
if strings.Contains(*opt.DBInstanceClass, "micro") {
optSet[*opt.DBInstanceClass] = struct{}{}
}
}
var optChoices []string
for opt := range optSet {
optChoices = append(optChoices, opt)
}
sort.Strings(optChoices)
optIndex := scenario.questioner.AskChoice(
"The available micro DB instance classes for your database engine are:\n", optChoices)
storageType := "standard"
allocatedStorage := int32(5)
log.Printf("Creating a DB instance named %v and database %v.\n"+
"The DB instance is configured to use your custom parameter group %v,\n"+
"selected engine %v,\n"+
"selected DB instance class %v,"+
"and %v GiB of %v storage.\n"+
"This typically takes several minutes.",
instanceName, dbName, *parameterGroup.DBParameterGroupName, *engineSelection.EngineVersion,
optChoices[optIndex], allocatedStorage, storageType)
instance, err = scenario.instances.CreateInstance(
ctx, instanceName, dbName, *engineSelection.Engine, *engineSelection.EngineVersion,
*parameterGroup.DBParameterGroupName, optChoices[optIndex], storageType,
allocatedStorage, adminUsername, adminPassword)
if err != nil {
panic(err)
}
for *instance.DBInstanceStatus != "available" {
scenario.helper.Pause(30)
instance, err = scenario.instances.GetInstance(ctx, instanceName)
if err != nil {
panic(err)
}
}
log.Println("Instance created and available.")
}
log.Println("Instance data:")
log.Printf("\tDBInstanceIdentifier: %v\n", *instance.DBInstanceIdentifier)
log.Printf("\tARN: %v\n", *instance.DBInstanceArn)
log.Printf("\tStatus: %v\n", *instance.DBInstanceStatus)
log.Printf("\tEngine: %v\n", *instance.Engine)
log.Printf("\tEngine version: %v\n", *instance.EngineVersion)
log.Println(strings.Repeat("-", 88))
return instance
}
// DisplayConnection displays connection information about a DB instance and tips
// on how to connect to it.
func (scenario GetStartedInstances) DisplayConnection(instance *types.DBInstance) {
log.Println(
"You can now connect to your database by using your favorite MySQL client.\n" +
"One way to connect is by using the 'mysql' shell on an Amazon EC2 instance\n" +
"that is running in the same VPC as your DB instance. Pass the endpoint,\n" +
"port, and administrator username to 'mysql'. Then, enter your password\n" +
"when prompted:")
log.Printf("\n\tmysql -h %v -P %v -u %v -p\n",
*instance.Endpoint.Address, instance.Endpoint.Port, *instance.MasterUsername)
log.Println("For more information, see the User Guide for RDS:\n" +
"\thttps://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_GettingStarted.CreatingConnecting.MySQL.html#CHAP_GettingStarted.Connecting.MySQL")
log.Println(strings.Repeat("-", 88))
}
// CreateSnapshot shows how to create a DB instance snapshot and wait until it's available.
func (scenario GetStartedInstances) CreateSnapshot(ctx context.Context, instance *types.DBInstance) {
if scenario.questioner.AskBool(
"Do you want to create a snapshot of your DB instance (y/n)? ", "y") {
snapshotId := fmt.Sprintf("%v-%v", *instance.DBInstanceIdentifier, scenario.helper.UniqueId())
log.Printf("Creating a snapshot named %v. This typically takes a few minutes.\n", snapshotId)
snapshot, err := scenario.instances.CreateSnapshot(ctx, *instance.DBInstanceIdentifier, snapshotId)
if err != nil {
panic(err)
}
for *snapshot.Status != "available" {
scenario.helper.Pause(30)
snapshot, err = scenario.instances.GetSnapshot(ctx, snapshotId)
if err != nil {
panic(err)
}
}
log.Println("Snapshot data:")
log.Printf("\tDBSnapshotIdentifier: %v\n", *snapshot.DBSnapshotIdentifier)
log.Printf("\tARN: %v\n", *snapshot.DBSnapshotArn)
log.Printf("\tStatus: %v\n", *snapshot.Status)
log.Printf("\tEngine: %v\n", *snapshot.Engine)
log.Printf("\tEngine version: %v\n", *snapshot.EngineVersion)
log.Printf("\tDBInstanceIdentifier: %v\n", *snapshot.DBInstanceIdentifier)
log.Printf("\tSnapshotCreateTime: %v\n", *snapshot.SnapshotCreateTime)
log.Println(strings.Repeat("-", 88))
}
}
// Cleanup shows how to clean up a DB instance and DB parameter group.
// Before the DB parameter group can be deleted, all associated DB instances must first be deleted.
func (scenario GetStartedInstances) Cleanup(
ctx context.Context, instance *types.DBInstance, parameterGroup *types.DBParameterGroup) {
if scenario.questioner.AskBool(
"\nDo you want to delete the database instance and parameter group (y/n)? ", "y") {
log.Printf("Deleting database instance %v.\n", *instance.DBInstanceIdentifier)
err := scenario.instances.DeleteInstance(ctx, *instance.DBInstanceIdentifier)
if err != nil {
panic(err)
}
log.Println(
"Waiting for the DB instance to delete. This typically takes several minutes.")
for instance != nil {
scenario.helper.Pause(30)
instance, err = scenario.instances.GetInstance(ctx, *instance.DBInstanceIdentifier)
if err != nil {
panic(err)
}
}
log.Printf("Deleting parameter group %v.", *parameterGroup.DBParameterGroupName)
err = scenario.instances.DeleteParameterGroup(ctx, *parameterGroup.DBParameterGroupName)
if err != nil {
panic(err)
}
}
}
// IScenarioHelper abstracts the function from a scenario so that it
// can be mocked for unit testing.
type IScenarioHelper interface {
Pause(secs int)
UniqueId() string
}
type ScenarioHelper struct{}
// Pause waits for the specified number of seconds.
func (helper ScenarioHelper) Pause(secs int) {
time.Sleep(time.Duration(secs) * time.Second)
}
// UniqueId returns a new UUID.
func (helper ScenarioHelper) UniqueId() string {
return uuid.New().String()
}
```
Amazon RDS アクションを管理するためにシナリオによって呼び出される関数を定義します。
```
import (
"context"
"errors"
"log"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/rds"
"github.com/aws/aws-sdk-go-v2/service/rds/types"
)
type DbInstances struct {
RdsClient *rds.Client
}
// GetParameterGroup gets a DB parameter group by name.
func (instances *DbInstances) GetParameterGroup(ctx context.Context, parameterGroupName string) (
*types.DBParameterGroup, error) {
output, err := instances.RdsClient.DescribeDBParameterGroups(
ctx, &rds.DescribeDBParameterGroupsInput{
DBParameterGroupName: aws.String(parameterGroupName),
})
if err != nil {
var notFoundError *types.DBParameterGroupNotFoundFault
if errors.As(err, ¬FoundError) {
log.Printf("Parameter group %v does not exist.\n", parameterGroupName)
err = nil
} else {
log.Printf("Error getting parameter group %v: %v\n", parameterGroupName, err)
}
return nil, err
} else {
return &output.DBParameterGroups[0], err
}
}
// CreateParameterGroup creates a DB parameter group that is based on the specified
// parameter group family.
func (instances *DbInstances) CreateParameterGroup(
ctx context.Context, parameterGroupName string, parameterGroupFamily string, description string) (
*types.DBParameterGroup, error) {
output, err := instances.RdsClient.CreateDBParameterGroup(ctx,
&rds.CreateDBParameterGroupInput{
DBParameterGroupName: aws.String(parameterGroupName),
DBParameterGroupFamily: aws.String(parameterGroupFamily),
Description: aws.String(description),
})
if err != nil {
log.Printf("Couldn't create parameter group %v: %v\n", parameterGroupName, err)
return nil, err
} else {
return output.DBParameterGroup, err
}
}
// DeleteParameterGroup deletes the named DB parameter group.
func (instances *DbInstances) DeleteParameterGroup(ctx context.Context, parameterGroupName string) error {
_, err := instances.RdsClient.DeleteDBParameterGroup(ctx,
&rds.DeleteDBParameterGroupInput{
DBParameterGroupName: aws.String(parameterGroupName),
})
if err != nil {
log.Printf("Couldn't delete parameter group %v: %v\n", parameterGroupName, err)
return err
} else {
return nil
}
}
// GetParameters gets the parameters that are contained in a DB parameter group.
func (instances *DbInstances) GetParameters(ctx context.Context, parameterGroupName string, source string) (
[]types.Parameter, error) {
var output *rds.DescribeDBParametersOutput
var params []types.Parameter
var err error
parameterPaginator := rds.NewDescribeDBParametersPaginator(instances.RdsClient,
&rds.DescribeDBParametersInput{
DBParameterGroupName: aws.String(parameterGroupName),
Source: aws.String(source),
})
for parameterPaginator.HasMorePages() {
output, err = parameterPaginator.NextPage(ctx)
if err != nil {
log.Printf("Couldn't get parameters for %v: %v\n", parameterGroupName, err)
break
} else {
params = append(params, output.Parameters...)
}
}
return params, err
}
// UpdateParameters updates parameters in a named DB parameter group.
func (instances *DbInstances) UpdateParameters(ctx context.Context, parameterGroupName string, params []types.Parameter) error {
_, err := instances.RdsClient.ModifyDBParameterGroup(ctx,
&rds.ModifyDBParameterGroupInput{
DBParameterGroupName: aws.String(parameterGroupName),
Parameters: params,
})
if err != nil {
log.Printf("Couldn't update parameters in %v: %v\n", parameterGroupName, err)
return err
} else {
return nil
}
}
// CreateSnapshot creates a snapshot of a DB instance.
func (instances *DbInstances) CreateSnapshot(ctx context.Context, instanceName string, snapshotName string) (
*types.DBSnapshot, error) {
output, err := instances.RdsClient.CreateDBSnapshot(ctx, &rds.CreateDBSnapshotInput{
DBInstanceIdentifier: aws.String(instanceName),
DBSnapshotIdentifier: aws.String(snapshotName),
})
if err != nil {
log.Printf("Couldn't create snapshot %v: %v\n", snapshotName, err)
return nil, err
} else {
return output.DBSnapshot, nil
}
}
// GetSnapshot gets a DB instance snapshot.
func (instances *DbInstances) GetSnapshot(ctx context.Context, snapshotName string) (*types.DBSnapshot, error) {
output, err := instances.RdsClient.DescribeDBSnapshots(ctx,
&rds.DescribeDBSnapshotsInput{
DBSnapshotIdentifier: aws.String(snapshotName),
})
if err != nil {
log.Printf("Couldn't get snapshot %v: %v\n", snapshotName, err)
return nil, err
} else {
return &output.DBSnapshots[0], nil
}
}
// CreateInstance creates a DB instance.
func (instances *DbInstances) CreateInstance(ctx context.Context, instanceName string, dbName string,
dbEngine string, dbEngineVersion string, parameterGroupName string, dbInstanceClass string,
storageType string, allocatedStorage int32, adminName string, adminPassword string) (
*types.DBInstance, error) {
output, err := instances.RdsClient.CreateDBInstance(ctx, &rds.CreateDBInstanceInput{
DBInstanceIdentifier: aws.String(instanceName),
DBName: aws.String(dbName),
DBParameterGroupName: aws.String(parameterGroupName),
Engine: aws.String(dbEngine),
EngineVersion: aws.String(dbEngineVersion),
DBInstanceClass: aws.String(dbInstanceClass),
StorageType: aws.String(storageType),
AllocatedStorage: aws.Int32(allocatedStorage),
MasterUsername: aws.String(adminName),
MasterUserPassword: aws.String(adminPassword),
})
if err != nil {
log.Printf("Couldn't create instance %v: %v\n", instanceName, err)
return nil, err
} else {
return output.DBInstance, nil
}
}
// GetInstance gets data about a DB instance.
func (instances *DbInstances) GetInstance(ctx context.Context, instanceName string) (
*types.DBInstance, error) {
output, err := instances.RdsClient.DescribeDBInstances(ctx,
&rds.DescribeDBInstancesInput{
DBInstanceIdentifier: aws.String(instanceName),
})
if err != nil {
var notFoundError *types.DBInstanceNotFoundFault
if errors.As(err, ¬FoundError) {
log.Printf("DB instance %v does not exist.\n", instanceName)
err = nil
} else {
log.Printf("Couldn't get instance %v: %v\n", instanceName, err)
}
return nil, err
} else {
return &output.DBInstances[0], nil
}
}
// DeleteInstance deletes a DB instance.
func (instances *DbInstances) DeleteInstance(ctx context.Context, instanceName string) error {
_, err := instances.RdsClient.DeleteDBInstance(ctx, &rds.DeleteDBInstanceInput{
DBInstanceIdentifier: aws.String(instanceName),
SkipFinalSnapshot: aws.Bool(true),
DeleteAutomatedBackups: aws.Bool(true),
})
if err != nil {
log.Printf("Couldn't delete instance %v: %v\n", instanceName, err)
return err
} else {
return nil
}
}
// GetEngineVersions gets database engine versions that are available for the specified engine
// and parameter group family.
func (instances *DbInstances) GetEngineVersions(ctx context.Context, engine string, parameterGroupFamily string) (
[]types.DBEngineVersion, error) {
output, err := instances.RdsClient.DescribeDBEngineVersions(ctx,
&rds.DescribeDBEngineVersionsInput{
Engine: aws.String(engine),
DBParameterGroupFamily: aws.String(parameterGroupFamily),
})
if err != nil {
log.Printf("Couldn't get engine versions for %v: %v\n", engine, err)
return nil, err
} else {
return output.DBEngineVersions, nil
}
}
// GetOrderableInstances uses a paginator to get DB instance options that can be used to create DB instances that are
// compatible with a set of specifications.
func (instances *DbInstances) GetOrderableInstances(ctx context.Context, engine string, engineVersion string) (
[]types.OrderableDBInstanceOption, error) {
var output *rds.DescribeOrderableDBInstanceOptionsOutput
var instanceOptions []types.OrderableDBInstanceOption
var err error
orderablePaginator := rds.NewDescribeOrderableDBInstanceOptionsPaginator(instances.RdsClient,
&rds.DescribeOrderableDBInstanceOptionsInput{
Engine: aws.String(engine),
EngineVersion: aws.String(engineVersion),
})
for orderablePaginator.HasMorePages() {
output, err = orderablePaginator.NextPage(ctx)
if err != nil {
log.Printf("Couldn't get orderable DB instance options: %v\n", err)
break
} else {
instanceOptions = append(instanceOptions, output.OrderableDBInstanceOptions...)
}
}
return instanceOptions, err
}
```
+ API の詳細については、「*AWS SDK for Go API リファレンス*」の以下のトピックを参照してください。
+ [CreateDBInstance](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/rds#Client.CreateDBInstance)
+ [CreateDBParameterGroup](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/rds#Client.CreateDBParameterGroup)
+ [CreateDBSnapshot](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/rds#Client.CreateDBSnapshot)
+ [DeleteDBInstance](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/rds#Client.DeleteDBInstance)
+ [DeleteDBParameterGroup](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/rds#Client.DeleteDBParameterGroup)
+ [DescribeDBEngineVersions](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/rds#Client.DescribeDBEngineVersions)
+ [DescribeDBInstances](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/rds#Client.DescribeDBInstances)
+ [DescribeDBParameterGroups](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/rds#Client.DescribeDBParameterGroups)
+ [DescribeDBParameters](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/rds#Client.DescribeDBParameters)
+ [DescribeDBSnapshots](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/rds#Client.DescribeDBSnapshots)
+ [DescribeOrderableDBInstanceOptions](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/rds#Client.DescribeOrderableDBInstanceOptions)
+ [ModifyDBParameterGroup](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/rds#Client.ModifyDBParameterGroup)
## アクション
### `CreateDBInstance`
次のコード例は、`CreateDBInstance` を使用する方法を示しています。
**SDK for Go V2**
GitHub には、その他のリソースもあります。用例一覧を検索し、[AWS コード例リポジトリ](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/rds#code-examples)での設定と実行の方法を確認してください。
```
import (
"context"
"errors"
"log"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/rds"
"github.com/aws/aws-sdk-go-v2/service/rds/types"
)
type DbInstances struct {
RdsClient *rds.Client
}
// CreateInstance creates a DB instance.
func (instances *DbInstances) CreateInstance(ctx context.Context, instanceName string, dbName string,
dbEngine string, dbEngineVersion string, parameterGroupName string, dbInstanceClass string,
storageType string, allocatedStorage int32, adminName string, adminPassword string) (
*types.DBInstance, error) {
output, err := instances.RdsClient.CreateDBInstance(ctx, &rds.CreateDBInstanceInput{
DBInstanceIdentifier: aws.String(instanceName),
DBName: aws.String(dbName),
DBParameterGroupName: aws.String(parameterGroupName),
Engine: aws.String(dbEngine),
EngineVersion: aws.String(dbEngineVersion),
DBInstanceClass: aws.String(dbInstanceClass),
StorageType: aws.String(storageType),
AllocatedStorage: aws.Int32(allocatedStorage),
MasterUsername: aws.String(adminName),
MasterUserPassword: aws.String(adminPassword),
})
if err != nil {
log.Printf("Couldn't create instance %v: %v\n", instanceName, err)
return nil, err
} else {
return output.DBInstance, nil
}
}
```
+ API の詳細については、*AWS SDK for Go API リファレンス*の「[CreateDBInstance](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/rds#Client.CreateDBInstance)」を参照してください。
### `CreateDBParameterGroup`
次のコード例は、`CreateDBParameterGroup` を使用する方法を示しています。
**SDK for Go V2**
GitHub には、その他のリソースもあります。用例一覧を検索し、[AWS コード例リポジトリ](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/rds#code-examples)での設定と実行の方法を確認してください。
```
import (
"context"
"errors"
"log"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/rds"
"github.com/aws/aws-sdk-go-v2/service/rds/types"
)
type DbInstances struct {
RdsClient *rds.Client
}
// CreateParameterGroup creates a DB parameter group that is based on the specified
// parameter group family.
func (instances *DbInstances) CreateParameterGroup(
ctx context.Context, parameterGroupName string, parameterGroupFamily string, description string) (
*types.DBParameterGroup, error) {
output, err := instances.RdsClient.CreateDBParameterGroup(ctx,
&rds.CreateDBParameterGroupInput{
DBParameterGroupName: aws.String(parameterGroupName),
DBParameterGroupFamily: aws.String(parameterGroupFamily),
Description: aws.String(description),
})
if err != nil {
log.Printf("Couldn't create parameter group %v: %v\n", parameterGroupName, err)
return nil, err
} else {
return output.DBParameterGroup, err
}
}
```
+ 詳細については、**「AWS SDK for Go API リファレンス」の「[CreateDBParameterGroup](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/rds#Client.CreateDBParameterGroup)」を参照してください。
### `CreateDBSnapshot`
次のコード例は、`CreateDBSnapshot` を使用する方法を示しています。
**SDK for Go V2**
GitHub には、その他のリソースもあります。用例一覧を検索し、[AWS コード例リポジトリ](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/rds#code-examples)での設定と実行の方法を確認してください。
```
import (
"context"
"errors"
"log"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/rds"
"github.com/aws/aws-sdk-go-v2/service/rds/types"
)
type DbInstances struct {
RdsClient *rds.Client
}
// CreateSnapshot creates a snapshot of a DB instance.
func (instances *DbInstances) CreateSnapshot(ctx context.Context, instanceName string, snapshotName string) (
*types.DBSnapshot, error) {
output, err := instances.RdsClient.CreateDBSnapshot(ctx, &rds.CreateDBSnapshotInput{
DBInstanceIdentifier: aws.String(instanceName),
DBSnapshotIdentifier: aws.String(snapshotName),
})
if err != nil {
log.Printf("Couldn't create snapshot %v: %v\n", snapshotName, err)
return nil, err
} else {
return output.DBSnapshot, nil
}
}
```
+ API の詳細については、**「AWS SDK for Go API リファレンス」の「[CreateDBSnapshot](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/rds#Client.CreateDBSnapshot)」を参照してください。
### `DeleteDBInstance`
次のコード例は、`DeleteDBInstance` を使用する方法を示しています。
**SDK for Go V2**
GitHub には、その他のリソースもあります。用例一覧を検索し、[AWS コード例リポジトリ](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/rds#code-examples)での設定と実行の方法を確認してください。
```
import (
"context"
"errors"
"log"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/rds"
"github.com/aws/aws-sdk-go-v2/service/rds/types"
)
type DbInstances struct {
RdsClient *rds.Client
}
// DeleteInstance deletes a DB instance.
func (instances *DbInstances) DeleteInstance(ctx context.Context, instanceName string) error {
_, err := instances.RdsClient.DeleteDBInstance(ctx, &rds.DeleteDBInstanceInput{
DBInstanceIdentifier: aws.String(instanceName),
SkipFinalSnapshot: aws.Bool(true),
DeleteAutomatedBackups: aws.Bool(true),
})
if err != nil {
log.Printf("Couldn't delete instance %v: %v\n", instanceName, err)
return err
} else {
return nil
}
}
```
+ API の詳細については、*AWS SDK for Go API リファレンス*の「[DeleteDBInstance](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/rds#Client.DeleteDBInstance)」を参照してください。
### `DeleteDBParameterGroup`
次のコード例は、`DeleteDBParameterGroup` を使用する方法を示しています。
**SDK for Go V2**
GitHub には、その他のリソースもあります。用例一覧を検索し、[AWS コード例リポジトリ](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/rds#code-examples)での設定と実行の方法を確認してください。
```
import (
"context"
"errors"
"log"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/rds"
"github.com/aws/aws-sdk-go-v2/service/rds/types"
)
type DbInstances struct {
RdsClient *rds.Client
}
// DeleteParameterGroup deletes the named DB parameter group.
func (instances *DbInstances) DeleteParameterGroup(ctx context.Context, parameterGroupName string) error {
_, err := instances.RdsClient.DeleteDBParameterGroup(ctx,
&rds.DeleteDBParameterGroupInput{
DBParameterGroupName: aws.String(parameterGroupName),
})
if err != nil {
log.Printf("Couldn't delete parameter group %v: %v\n", parameterGroupName, err)
return err
} else {
return nil
}
}
```
+ 詳細については、**「AWS SDK for Go API リファレンス」の「[DeleteDBParameterGroup](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/rds#Client.DeleteDBParameterGroup)」を参照してください。
### `DescribeDBEngineVersions`
次のコード例は、`DescribeDBEngineVersions` を使用する方法を示しています。
**SDK for Go V2**
GitHub には、その他のリソースもあります。用例一覧を検索し、[AWS コード例リポジトリ](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/rds#code-examples)での設定と実行の方法を確認してください。
```
import (
"context"
"errors"
"log"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/rds"
"github.com/aws/aws-sdk-go-v2/service/rds/types"
)
type DbInstances struct {
RdsClient *rds.Client
}
// GetEngineVersions gets database engine versions that are available for the specified engine
// and parameter group family.
func (instances *DbInstances) GetEngineVersions(ctx context.Context, engine string, parameterGroupFamily string) (
[]types.DBEngineVersion, error) {
output, err := instances.RdsClient.DescribeDBEngineVersions(ctx,
&rds.DescribeDBEngineVersionsInput{
Engine: aws.String(engine),
DBParameterGroupFamily: aws.String(parameterGroupFamily),
})
if err != nil {
log.Printf("Couldn't get engine versions for %v: %v\n", engine, err)
return nil, err
} else {
return output.DBEngineVersions, nil
}
}
```
+ API の詳細については、*AWS SDK for Go API リファレンス*の「[DescribeDBEngineVersions](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/rds#Client.DescribeDBEngineVersions)」を参照してください。
### `DescribeDBInstances`
次のコード例は、`DescribeDBInstances` を使用する方法を示しています。
**SDK for Go V2**
GitHub には、その他のリソースもあります。用例一覧を検索し、[AWS コード例リポジトリ](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/rds#code-examples)での設定と実行の方法を確認してください。
```
import (
"context"
"errors"
"log"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/rds"
"github.com/aws/aws-sdk-go-v2/service/rds/types"
)
type DbInstances struct {
RdsClient *rds.Client
}
// GetInstance gets data about a DB instance.
func (instances *DbInstances) GetInstance(ctx context.Context, instanceName string) (
*types.DBInstance, error) {
output, err := instances.RdsClient.DescribeDBInstances(ctx,
&rds.DescribeDBInstancesInput{
DBInstanceIdentifier: aws.String(instanceName),
})
if err != nil {
var notFoundError *types.DBInstanceNotFoundFault
if errors.As(err, ¬FoundError) {
log.Printf("DB instance %v does not exist.\n", instanceName)
err = nil
} else {
log.Printf("Couldn't get instance %v: %v\n", instanceName, err)
}
return nil, err
} else {
return &output.DBInstances[0], nil
}
}
```
+ API の詳細については、*AWS SDK for Go API リファレンス*の「[DescribeDBInstances](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/rds#Client.DescribeDBInstances)」を参照してください。
### `DescribeDBParameterGroups`
次のコード例は、`DescribeDBParameterGroups` を使用する方法を示しています。
**SDK for Go V2**
GitHub には、その他のリソースもあります。用例一覧を検索し、[AWS コード例リポジトリ](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/rds#code-examples)での設定と実行の方法を確認してください。
```
import (
"context"
"errors"
"log"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/rds"
"github.com/aws/aws-sdk-go-v2/service/rds/types"
)
type DbInstances struct {
RdsClient *rds.Client
}
// GetParameterGroup gets a DB parameter group by name.
func (instances *DbInstances) GetParameterGroup(ctx context.Context, parameterGroupName string) (
*types.DBParameterGroup, error) {
output, err := instances.RdsClient.DescribeDBParameterGroups(
ctx, &rds.DescribeDBParameterGroupsInput{
DBParameterGroupName: aws.String(parameterGroupName),
})
if err != nil {
var notFoundError *types.DBParameterGroupNotFoundFault
if errors.As(err, ¬FoundError) {
log.Printf("Parameter group %v does not exist.\n", parameterGroupName)
err = nil
} else {
log.Printf("Error getting parameter group %v: %v\n", parameterGroupName, err)
}
return nil, err
} else {
return &output.DBParameterGroups[0], err
}
}
```
+ API の詳細については、**「AWS SDK for Go API リファレンス」の「[DescribeDBParameterGroups](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/rds#Client.DescribeDBParameterGroups)」を参照してください。
### `DescribeDBParameters`
次のコード例は、`DescribeDBParameters` を使用する方法を示しています。
**SDK for Go V2**
GitHub には、その他のリソースもあります。用例一覧を検索し、[AWS コード例リポジトリ](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/rds#code-examples)での設定と実行の方法を確認してください。
```
import (
"context"
"errors"
"log"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/rds"
"github.com/aws/aws-sdk-go-v2/service/rds/types"
)
type DbInstances struct {
RdsClient *rds.Client
}
// GetParameters gets the parameters that are contained in a DB parameter group.
func (instances *DbInstances) GetParameters(ctx context.Context, parameterGroupName string, source string) (
[]types.Parameter, error) {
var output *rds.DescribeDBParametersOutput
var params []types.Parameter
var err error
parameterPaginator := rds.NewDescribeDBParametersPaginator(instances.RdsClient,
&rds.DescribeDBParametersInput{
DBParameterGroupName: aws.String(parameterGroupName),
Source: aws.String(source),
})
for parameterPaginator.HasMorePages() {
output, err = parameterPaginator.NextPage(ctx)
if err != nil {
log.Printf("Couldn't get parameters for %v: %v\n", parameterGroupName, err)
break
} else {
params = append(params, output.Parameters...)
}
}
return params, err
}
```
+ API の詳細については、**「AWS SDK for Go API リファレンス」の「[DescribeDBParameters](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/rds#Client.DescribeDBParameters)」を参照してください。
### `DescribeDBSnapshots`
次のコード例は、`DescribeDBSnapshots` を使用する方法を示しています。
**SDK for Go V2**
GitHub には、その他のリソースもあります。用例一覧を検索し、[AWS コード例リポジトリ](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/rds#code-examples)での設定と実行の方法を確認してください。
```
import (
"context"
"errors"
"log"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/rds"
"github.com/aws/aws-sdk-go-v2/service/rds/types"
)
type DbInstances struct {
RdsClient *rds.Client
}
// GetSnapshot gets a DB instance snapshot.
func (instances *DbInstances) GetSnapshot(ctx context.Context, snapshotName string) (*types.DBSnapshot, error) {
output, err := instances.RdsClient.DescribeDBSnapshots(ctx,
&rds.DescribeDBSnapshotsInput{
DBSnapshotIdentifier: aws.String(snapshotName),
})
if err != nil {
log.Printf("Couldn't get snapshot %v: %v\n", snapshotName, err)
return nil, err
} else {
return &output.DBSnapshots[0], nil
}
}
```
+ API の詳細については、**「AWS SDK for Go API リファレンス」の「[DescribeDBSnapshots](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/rds#Client.DescribeDBSnapshots)」を参照してください。
### `DescribeOrderableDBInstanceOptions`
次のコード例は、`DescribeOrderableDBInstanceOptions` を使用する方法を示しています。
**SDK for Go V2**
GitHub には、その他のリソースもあります。用例一覧を検索し、[AWS コード例リポジトリ](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/rds#code-examples)での設定と実行の方法を確認してください。
```
import (
"context"
"errors"
"log"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/rds"
"github.com/aws/aws-sdk-go-v2/service/rds/types"
)
type DbInstances struct {
RdsClient *rds.Client
}
// GetOrderableInstances uses a paginator to get DB instance options that can be used to create DB instances that are
// compatible with a set of specifications.
func (instances *DbInstances) GetOrderableInstances(ctx context.Context, engine string, engineVersion string) (
[]types.OrderableDBInstanceOption, error) {
var output *rds.DescribeOrderableDBInstanceOptionsOutput
var instanceOptions []types.OrderableDBInstanceOption
var err error
orderablePaginator := rds.NewDescribeOrderableDBInstanceOptionsPaginator(instances.RdsClient,
&rds.DescribeOrderableDBInstanceOptionsInput{
Engine: aws.String(engine),
EngineVersion: aws.String(engineVersion),
})
for orderablePaginator.HasMorePages() {
output, err = orderablePaginator.NextPage(ctx)
if err != nil {
log.Printf("Couldn't get orderable DB instance options: %v\n", err)
break
} else {
instanceOptions = append(instanceOptions, output.OrderableDBInstanceOptions...)
}
}
return instanceOptions, err
}
```
+ API の詳細については、*AWS SDK for Go API リファレンス*の「[DescribeOrderableDBInstanceOptions](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/rds#Client.DescribeOrderableDBInstanceOptions)」を参照してください。
### `ModifyDBParameterGroup`
次のコード例は、`ModifyDBParameterGroup` を使用する方法を示しています。
**SDK for Go V2**
GitHub には、その他のリソースもあります。用例一覧を検索し、[AWS コード例リポジトリ](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/rds#code-examples)での設定と実行の方法を確認してください。
```
import (
"context"
"errors"
"log"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/rds"
"github.com/aws/aws-sdk-go-v2/service/rds/types"
)
type DbInstances struct {
RdsClient *rds.Client
}
// UpdateParameters updates parameters in a named DB parameter group.
func (instances *DbInstances) UpdateParameters(ctx context.Context, parameterGroupName string, params []types.Parameter) error {
_, err := instances.RdsClient.ModifyDBParameterGroup(ctx,
&rds.ModifyDBParameterGroupInput{
DBParameterGroupName: aws.String(parameterGroupName),
Parameters: params,
})
if err != nil {
log.Printf("Couldn't update parameters in %v: %v\n", parameterGroupName, err)
return err
} else {
return nil
}
}
```
+ API の詳細については、**「AWS SDK for Go API リファレンス」の「[ModifyDBParameterGroup](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/rds#Client.ModifyDBParameterGroup)」を参照してください。
## サーバーレスサンプル
### Lambda 関数での Amazon RDS データベースへの接続
次のコード例は、RDS データベースに接続する Lambda 関数を実装する方法を示しています。この関数は、シンプルなデータベースリクエストを実行し、結果を返します。
**SDK for Go V2**
GitHub には、その他のリソースもあります。[サーバーレスサンプル](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-connect-rds-iam)リポジトリで完全な例を見つけて、設定と実行の方法を確認してください。
Go を使用した Lambda 関数での Amazon RDS データベースへの接続
```
/*
Golang v2 code here.
*/
package main
import (
"context"
"database/sql"
"encoding/json"
"fmt"
"os"
"github.com/aws/aws-lambda-go/lambda"
"github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/aws-sdk-go-v2/feature/rds/auth"
_ "github.com/go-sql-driver/mysql"
)
type MyEvent struct {
Name string `json:"name"`
}
func HandleRequest(event *MyEvent) (map[string]interface{}, error) {
var dbName string = os.Getenv("DatabaseName")
var dbUser string = os.Getenv("DatabaseUser")
var dbHost string = os.Getenv("DBHost") // Add hostname without https
var dbPort int = os.Getenv("Port") // Add port number
var dbEndpoint string = fmt.Sprintf("%s:%d", dbHost, dbPort)
var region string = os.Getenv("AWS_REGION")
cfg, err := config.LoadDefaultConfig(context.TODO())
if err != nil {
panic("configuration error: " + err.Error())
}
authenticationToken, err := auth.BuildAuthToken(
context.TODO(), dbEndpoint, region, dbUser, cfg.Credentials)
if err != nil {
panic("failed to create authentication token: " + err.Error())
}
dsn := fmt.Sprintf("%s:%s@tcp(%s)/%s?tls=true&allowCleartextPasswords=true",
dbUser, authenticationToken, dbEndpoint, dbName,
)
db, err := sql.Open("mysql", dsn)
if err != nil {
panic(err)
}
defer db.Close()
var sum int
err = db.QueryRow("SELECT ?+? AS sum", 3, 2).Scan(&sum)
if err != nil {
panic(err)
}
s := fmt.Sprint(sum)
message := fmt.Sprintf("The selected sum is: %s", s)
messageBytes, err := json.Marshal(message)
if err != nil {
return nil, err
}
messageString := string(messageBytes)
return map[string]interface{}{
"statusCode": 200,
"headers": map[string]string{"Content-Type": "application/json"},
"body": messageString,
}, nil
}
func main() {
lambda.Start(HandleRequest)
}
```