GS2-Stamina GS2-Deploy/CDK リファレンス

GS2-Deployのスタックの作成に使用するテンプレートのフォーマットと、CDKによる各種言語のテンプレート出力の実装例

エンティティ

Namespace

ネームスペース

ネームスペースは一つのプロジェクトで同じサービスを異なる用途で複数利用できるようにするための仕組みです。
GS2 のサービスは基本的にネームスペースというレイヤーがあり、ネームスペースが異なれば同じサービスでもまったく別のデータ空間として取り扱われます。

そのため、各サービスの利用を開始するにあたってネームスペースを作成する必要があります。

必須デフォルト値の制限説明
namestring~ 128文字ネームスペース名
descriptionstring~ 1024文字説明文
overflowTriggerScriptstring~ 1024文字回復処理時にあふれたスタミナに対して処理をする GS2-Script
logSettingLogSettingログの出力設定

GetAttr

説明
ItemNamespace作成したネームスペース

実装例

Type: GS2::Stamina::Namespace
Properties:
  Name: namespace-0001
  Description: null
  OverflowTriggerScript: grn:gs2:ap-northeast-1:YourOwnerId:script:namespace-0001:script:script
  LogSetting: 
    LoggingNamespaceId: grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001
import "github.com/gs2io/gs2-golang-cdk/core"
import "github.com/gs2io/gs2-golang-cdk/stamina"
import "github.com/openlyinc/pointy"

SampleStack := core.NewStack()
stamina.NewNamespace(
    &SampleStack,
    "namespace-0001",
    stamina.NamespaceOptions{
        OverflowTriggerScript: "grn:gs2:ap-northeast-1:YourOwnerId:script:namespace-0001:script:script",
        LogSetting: &core.LogSetting{
            LoggingNamespaceId: "grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001",
        },
    },
)

println(SampleStack.Yaml())  // Generate Template
class SampleStack extends \Gs2Cdk\Core\Model\Stack
{
    function __construct() {
        parent::__construct();
        new \Gs2Cdk\Stamina\Model\Namespace_(
            stack: $this,
            name: "namespace-0001",
            options: new \Gs2Cdk\Stamina\Model\Options\NamespaceOptions(
                overflowTriggerScript: "grn:gs2:ap-northeast-1:YourOwnerId:script:namespace-0001:script:script",
                logSetting: new \Gs2Cdk\Core\Model\LogSetting(
                    loggingNamespaceId: "grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001"
                )
            )
        );
    }
}

print((new SampleStack())->yaml());  // Generate Template
class SampleStack extends io.gs2.cdk.core.model.Stack
{
    public SampleStack() {
        super();
        new io.gs2.cdk.stamina.model.Namespace(
                this,
                "namespace-0001",
                new io.gs2.cdk.stamina.model.options.NamespaceOptions()
                        .withOverflowTriggerScript("grn:gs2:ap-northeast-1:YourOwnerId:script:namespace-0001:script:script")
                        .withLogSetting(new io.gs2.cdk.core.model.LogSetting(
                            "grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001"
                        ))
        );
    }
}

System.out.println(new SampleStack().yaml());  // Generate Template
public class SampleStack : Gs2Cdk.Core.Model.Stack
{
    public SampleStack() {
        new Gs2Cdk.Gs2Stamina.Model.Namespace(
            stack: this,
            name: "namespace-0001",
            options: new Gs2Cdk.Gs2Stamina.Model.Options.NamespaceOptions
            {
                overflowTriggerScript = "grn:gs2:ap-northeast-1:YourOwnerId:script:namespace-0001:script:script",
                logSetting = new Gs2Cdk.Core.Model.LogSetting(
                    loggingNamespaceId: "grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001"
                )
            }
        );
    }
}

Debug.Log(new SampleStack().Yaml());  // Generate Template
import core from "@/gs2cdk/core";
import stamina from "@/gs2cdk/stamina";

class SampleStack extends core.Stack
{
    public constructor() {
        super();
        new stamina.model.Namespace(
            this,
            "namespace-0001",
            {
                overflowTriggerScript: "grn:gs2:ap-northeast-1:YourOwnerId:script:namespace-0001:script:script",
                logSetting: new core.LogSetting(
                    "grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001"
                )
            }
        );
    }
}

console.log(new SampleStack().yaml());  // Generate Template
from gs2_cdk import Stack, core, stamina

class SampleStack(Stack):

    def __init__(self):
        super().__init__()
        stamina.Namespace(
            stack=self,
            name='namespace-0001',
            options=stamina.NamespaceOptions(
                overflow_trigger_script='grn:gs2:ap-northeast-1:YourOwnerId:script:namespace-0001:script:script',
                log_setting=core.LogSetting(
                    logging_namespace_id='grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001',
                ),
            ),
        )

print(SampleStack().yaml())  # Generate Template

CurrentStaminaMaster

現在有効なマスターデータ

GS2ではマスターデータの管理にJSON形式のファイルを使用します。
ファイルをアップロードすることで、実際にサーバーに設定を反映することができます。

JSONファイルを作成する方法として、マネージメントコンソール上でのマスターデータエディタを提供していますが
よりゲームの運営に相応しいツールを作成し、適切なフォーマットのJSONファイルを書き出すことでもサービスを利用可能です。

必須デフォルト値の制限説明
namespaceNamestring~ 128文字ネームスペース名
settingsstring~ 5242880文字マスターデータ

GetAttr

説明
ItemCurrentStaminaMaster更新した現在有効なスタミナマスター

実装例

Type: GS2::Stamina::CurrentStaminaMaster
Properties:
  NamespaceName: namespace-0001
  Settings: {
    "version": "2019-02-14",
    "staminaModels": [
      {
        "name": "quest",
        "recoverIntervalMinutes": 15,
        "recoverValue": 1,
        "initialCapacity": 50,
        "isOverflow": true,
        "metadata": "QUEST",
        "maxCapacity": 999,
        "maxStaminaTable":
          {
            "name": "playerLevel",
            "metadata": "PLAYER_LEVEL",
            "experienceModelId": "playerLevel",
            "values": [
              51,
              52,
              53,
              54,
              55
            ]
          },
        "recoverIntervalTable":
          {
            "name": "staminaRecoverInterval",
            "metadata": "STAMINA_RECOVER_INTERVAL",
            "experienceModelId": "playerLevel",
            "values": [
              41,
              42,
              43,
              44,
              45
            ]
          },
        "recoverValueTable":
          {
            "name": "staminaRecoverValue",
            "metadata": "STAMINA_RECOVER_VALUE",
            "experienceModelId": "playerLevel",
            "values": [
              31,
              32,
              33,
              34,
              35
            ]
          }
      },
      {
        "name": "raidBattle",
        "recoverIntervalMinutes": 60,
        "recoverValue": 1,
        "initialCapacity": 10,
        "isOverflow": false,
        "metadata": "RAID_BATTLE"
      },
      {
        "name": "special",
        "recoverIntervalMinutes": 30,
        "recoverValue": 3,
        "initialCapacity": 100,
        "isOverflow": true,
        "metadata": "SPECIAL",
        "maxCapacity": 999,
        "maxStaminaTable":
          {
            "name": "special",
            "metadata": "SPECIAL",
            "experienceModelId": "special",
            "values": [
              102,
              104,
              106,
              108,
              110
            ]
          }
      }
    ]
  }
import "github.com/gs2io/gs2-golang-cdk/core"
import "github.com/gs2io/gs2-golang-cdk/stamina"
import "github.com/openlyinc/pointy"

SampleStack := core.NewStack()
stamina.NewNamespace(
    &SampleStack,
    "namespace-0001",
    stamina.NamespaceOptions{},
).MasterData(
    []stamina.StaminaModel{
        stamina.NewStaminaModel(
            "quest",
            15,
            1,
            50,
            true,
            stamina.StaminaModelOptions{
                Metadata: pointy.String("QUEST"),
                MaxCapacity: pointy.Int32(999),
                MaxStaminaTable: &stamina.NewMaxStaminaTable(
                    "playerLevel",
                    "playerLevel",
                    []int32{
                        51,
                        52,
                        53,
                        54,
                        55,
                    },
                    stamina.MaxStaminaTableOptions{
                        Metadata: pointy.String("PLAYER_LEVEL"),
                    },
                ),
                RecoverIntervalTable: &stamina.NewRecoverIntervalTable(
                    "staminaRecoverInterval",
                    "playerLevel",
                    []int32{
                        41,
                        42,
                        43,
                        44,
                        45,
                    },
                    stamina.RecoverIntervalTableOptions{
                        Metadata: pointy.String("STAMINA_RECOVER_INTERVAL"),
                    },
                ),
                RecoverValueTable: &stamina.NewRecoverValueTable(
                    "staminaRecoverValue",
                    "playerLevel",
                    []int32{
                        31,
                        32,
                        33,
                        34,
                        35,
                    },
                    stamina.RecoverValueTableOptions{
                        Metadata: pointy.String("STAMINA_RECOVER_VALUE"),
                    },
                ),
            },
        ),
        stamina.NewStaminaModel(
            "raidBattle",
            60,
            1,
            10,
            false,
            stamina.StaminaModelOptions{
                Metadata: pointy.String("RAID_BATTLE"),
            },
        ),
        stamina.NewStaminaModel(
            "special",
            30,
            3,
            100,
            true,
            stamina.StaminaModelOptions{
                Metadata: pointy.String("SPECIAL"),
                MaxCapacity: pointy.Int32(999),
                MaxStaminaTable: &stamina.NewMaxStaminaTable(
                    "special",
                    "special",
                    []int32{
                        102,
                        104,
                        106,
                        108,
                        110,
                    },
                    stamina.MaxStaminaTableOptions{
                        Metadata: pointy.String("SPECIAL"),
                    },
                ),
            },
        ),
    },
)

println(SampleStack.Yaml())  // Generate Template
class SampleStack extends \Gs2Cdk\Core\Model\Stack
{
    function __construct() {
        parent::__construct();
        (new \Gs2Cdk\Stamina\Model\Namespace_(
            stack: $this,
            name: "namespace-0001"
        ))->masterData(
            [
                new \Gs2Cdk\Stamina\Model\StaminaModel(
                    name:"quest",
                    recoverIntervalMinutes:15,
                    recoverValue:1,
                    initialCapacity:50,
                    isOverflow:True,
                    options: new \Gs2Cdk\Stamina\Model\Options\StaminaModelOptions(
                        metadata:"QUEST",
                        maxCapacity:999,
                        maxStaminaTable:new \Gs2Cdk\Stamina\Model\MaxStaminaTable(
                            name: "playerLevel",
                            experienceModelId: "playerLevel",
                            values: [
                                51,
                                52,
                                53,
                                54,
                                55,
                            ],
                            options: new \Gs2Cdk\Stamina\Model\Options\MaxStaminaTableOptions(
                                metadata: "PLAYER_LEVEL",
                            )
                        ),
                        recoverIntervalTable:new \Gs2Cdk\Stamina\Model\RecoverIntervalTable(
                            name: "staminaRecoverInterval",
                            experienceModelId: "playerLevel",
                            values: [
                                41,
                                42,
                                43,
                                44,
                                45,
                            ],
                            options: new \Gs2Cdk\Stamina\Model\Options\RecoverIntervalTableOptions(
                                metadata: "STAMINA_RECOVER_INTERVAL",
                            )
                        ),
                        recoverValueTable:new \Gs2Cdk\Stamina\Model\RecoverValueTable(
                            name: "staminaRecoverValue",
                            experienceModelId: "playerLevel",
                            values: [
                                31,
                                32,
                                33,
                                34,
                                35,
                            ],
                            options: new \Gs2Cdk\Stamina\Model\Options\RecoverValueTableOptions(
                                metadata: "STAMINA_RECOVER_VALUE",
                            )
                        )
                    )
                ),
                new \Gs2Cdk\Stamina\Model\StaminaModel(
                    name:"raidBattle",
                    recoverIntervalMinutes:60,
                    recoverValue:1,
                    initialCapacity:10,
                    isOverflow:False,
                    options: new \Gs2Cdk\Stamina\Model\Options\StaminaModelOptions(
                        metadata:"RAID_BATTLE"
                    )
                ),
                new \Gs2Cdk\Stamina\Model\StaminaModel(
                    name:"special",
                    recoverIntervalMinutes:30,
                    recoverValue:3,
                    initialCapacity:100,
                    isOverflow:True,
                    options: new \Gs2Cdk\Stamina\Model\Options\StaminaModelOptions(
                        metadata:"SPECIAL",
                        maxCapacity:999,
                        maxStaminaTable:new \Gs2Cdk\Stamina\Model\MaxStaminaTable(
                            name: "special",
                            experienceModelId: "special",
                            values: [
                                102,
                                104,
                                106,
                                108,
                                110,
                            ],
                            options: new \Gs2Cdk\Stamina\Model\Options\MaxStaminaTableOptions(
                                metadata: "SPECIAL",
                            )
                        )
                    )
                )
            ]
        );
    }
}

print((new SampleStack())->yaml());  // Generate Template
class SampleStack extends io.gs2.cdk.core.model.Stack
{
    public SampleStack() {
        super();
        new io.gs2.cdk.stamina.model.Namespace(
            this,
            "namespace-0001"
        ).masterData(
            Arrays.asList(
                new io.gs2.cdk.stamina.model.StaminaModel(
                    "quest",
                    15,
                    1,
                    50,
                    true,
                    new io.gs2.cdk.stamina.model.options.StaminaModelOptions()
                            .withMetadata("QUEST")
                ),
                new io.gs2.cdk.stamina.model.StaminaModel(
                    "raidBattle",
                    60,
                    1,
                    10,
                    false,
                    new io.gs2.cdk.stamina.model.options.StaminaModelOptions()
                            .withMetadata("RAID_BATTLE")
                ),
                new io.gs2.cdk.stamina.model.StaminaModel(
                    "special",
                    30,
                    3,
                    100,
                    true,
                    new io.gs2.cdk.stamina.model.options.StaminaModelOptions()
                            .withMetadata("SPECIAL")
                )
            )
        );
    }
}

System.out.println(new SampleStack().yaml());  // Generate Template
public class SampleStack : Gs2Cdk.Core.Model.Stack
{
    public SampleStack() {
        new Gs2Cdk.Gs2Stamina.Model.Namespace(
            stack: this,
            name: "namespace-0001"
        ).MasterData(
            new Gs2Cdk.Gs2Stamina.Model.StaminaModel[] {
                new Gs2Cdk.Gs2Stamina.Model.StaminaModel(
                    name: "quest",
                    recoverIntervalMinutes: 15,
                    recoverValue: 1,
                    initialCapacity: 50,
                    isOverflow: true,
                    options: new Gs2Cdk.Gs2Stamina.Model.Options.StaminaModelOptions
                    {
                        metadata = "QUEST",
                        maxCapacity = 999,
                        maxStaminaTable = new Gs2Cdk.Gs2Stamina.Model.MaxStaminaTable(
                            name: "playerLevel",
                            experienceModelId: "playerLevel",
                            values: new int[]
                            {
                                51,
                                52,
                                53,
                                54,
                                55,
                            },
                            options: new Gs2Cdk.Gs2Stamina.Model.Options.MaxStaminaTableOptions
                            {
                                metadata = "PLAYER_LEVEL"
                            }
                        ),
                        recoverIntervalTable = new Gs2Cdk.Gs2Stamina.Model.RecoverIntervalTable(
                            name: "staminaRecoverInterval",
                            experienceModelId: "playerLevel",
                            values: new int[]
                            {
                                41,
                                42,
                                43,
                                44,
                                45,
                            },
                            options: new Gs2Cdk.Gs2Stamina.Model.Options.RecoverIntervalTableOptions
                            {
                                metadata = "STAMINA_RECOVER_INTERVAL"
                            }
                        ),
                        recoverValueTable = new Gs2Cdk.Gs2Stamina.Model.RecoverValueTable(
                            name: "staminaRecoverValue",
                            experienceModelId: "playerLevel",
                            values: new int[]
                            {
                                31,
                                32,
                                33,
                                34,
                                35,
                            },
                            options: new Gs2Cdk.Gs2Stamina.Model.Options.RecoverValueTableOptions
                            {
                                metadata = "STAMINA_RECOVER_VALUE"
                            }
                        )
                    }
                ),
                new Gs2Cdk.Gs2Stamina.Model.StaminaModel(
                    name: "raidBattle",
                    recoverIntervalMinutes: 60,
                    recoverValue: 1,
                    initialCapacity: 10,
                    isOverflow: false,
                    options: new Gs2Cdk.Gs2Stamina.Model.Options.StaminaModelOptions
                    {
                        metadata = "RAID_BATTLE"
                    }
                ),
                new Gs2Cdk.Gs2Stamina.Model.StaminaModel(
                    name: "special",
                    recoverIntervalMinutes: 30,
                    recoverValue: 3,
                    initialCapacity: 100,
                    isOverflow: true,
                    options: new Gs2Cdk.Gs2Stamina.Model.Options.StaminaModelOptions
                    {
                        metadata = "SPECIAL",
                        maxCapacity = 999,
                        maxStaminaTable = new Gs2Cdk.Gs2Stamina.Model.MaxStaminaTable(
                            name: "special",
                            experienceModelId: "special",
                            values: new int[]
                            {
                                102,
                                104,
                                106,
                                108,
                                110,
                            },
                            options: new Gs2Cdk.Gs2Stamina.Model.Options.MaxStaminaTableOptions
                            {
                                metadata = "SPECIAL"
                            }
                        )
                    }
                )
            }
        );
    }
}

Debug.Log(new SampleStack().Yaml());  // Generate Template
import core from "@/gs2cdk/core";
import stamina from "@/gs2cdk/stamina";

class SampleStack extends core.Stack
{
    public constructor() {
        super();
        new stamina.model.Namespace(
            this,
            "namespace-0001",
        ).masterData(
            [
                new stamina.model.StaminaModel(
                    "quest",
                    15,
                    1,
                    50,
                    true,
                    {
                        metadata: "QUEST",
                        maxCapacity: 999,
                        maxStaminaTable: new stamina.model.MaxStaminaTable(
                            "playerLevel",
                            "playerLevel",
                            [
                                51,
                                52,
                                53,
                                54,
                                55,
                            ],
                            {
                                metadata: "PLAYER_LEVEL"
                            }
                        ),
                        recoverIntervalTable: new stamina.model.RecoverIntervalTable(
                            "staminaRecoverInterval",
                            "playerLevel",
                            [
                                41,
                                42,
                                43,
                                44,
                                45,
                            ],
                            {
                                metadata: "STAMINA_RECOVER_INTERVAL"
                            }
                        ),
                        recoverValueTable: new stamina.model.RecoverValueTable(
                            "staminaRecoverValue",
                            "playerLevel",
                            [
                                31,
                                32,
                                33,
                                34,
                                35,
                            ],
                            {
                                metadata: "STAMINA_RECOVER_VALUE"
                            }
                        )
                    }
                ),
                new stamina.model.StaminaModel(
                    "raidBattle",
                    60,
                    1,
                    10,
                    false,
                    {
                        metadata: "RAID_BATTLE"
                    }
                ),
                new stamina.model.StaminaModel(
                    "special",
                    30,
                    3,
                    100,
                    true,
                    {
                        metadata: "SPECIAL",
                        maxCapacity: 999,
                        maxStaminaTable: new stamina.model.MaxStaminaTable(
                            "special",
                            "special",
                            [
                                102,
                                104,
                                106,
                                108,
                                110,
                            ],
                            {
                                metadata: "SPECIAL"
                            }
                        )
                    }
                )
            ]
        );
    }
}

console.log(new SampleStack().yaml());  // Generate Template
from gs2_cdk import Stack, core, stamina

class SampleStack(Stack):

    def __init__(self):
        super().__init__()
        stamina.Namespace(
            stack=self,
            name="namespace-0001",
        ).master_data(
            stamina_models=[
                stamina.StaminaModel(
                    name='quest',
                    recover_interval_minutes=15,
                    recover_value=1,
                    initial_capacity=50,
                    is_overflow=True,
                    options=stamina.StaminaModelOptions(
                        metadata = 'QUEST',
                        max_capacity = 999,
                        max_stamina_table = stamina.MaxStaminaTable(
                            name='playerLevel',
                            experience_model_id='playerLevel',
                            values=[
                                51,
                                52,
                                53,
                                54,
                                55,
                            ],
                            options=stamina.MaxStaminaTableOptions(
                                metadata='PLAYER_LEVEL',
                            ),
                        ),
                        recover_interval_table = stamina.RecoverIntervalTable(
                            name='staminaRecoverInterval',
                            experience_model_id='playerLevel',
                            values=[
                                41,
                                42,
                                43,
                                44,
                                45,
                            ],
                            options=stamina.RecoverIntervalTableOptions(
                                metadata='STAMINA_RECOVER_INTERVAL',
                            ),
                        ),
                        recover_value_table = stamina.RecoverValueTable(
                            name='staminaRecoverValue',
                            experience_model_id='playerLevel',
                            values=[
                                31,
                                32,
                                33,
                                34,
                                35,
                            ],
                            options=stamina.RecoverValueTableOptions(
                                metadata='STAMINA_RECOVER_VALUE',
                            ),
                        )
                    ),
                ),
                stamina.StaminaModel(
                    name='raidBattle',
                    recover_interval_minutes=60,
                    recover_value=1,
                    initial_capacity=10,
                    is_overflow=False,
                    options=stamina.StaminaModelOptions(
                        metadata = 'RAID_BATTLE'
                    ),
                ),
                stamina.StaminaModel(
                    name='special',
                    recover_interval_minutes=30,
                    recover_value=3,
                    initial_capacity=100,
                    is_overflow=True,
                    options=stamina.StaminaModelOptions(
                        metadata = 'SPECIAL',
                        max_capacity = 999,
                        max_stamina_table = stamina.MaxStaminaTable(
                            name='special',
                            experience_model_id='special',
                            values=[
                                102,
                                104,
                                106,
                                108,
                                110,
                            ],
                            options=stamina.MaxStaminaTableOptions(
                                metadata='SPECIAL',
                            ),
                        )
                    ),
                ),
            ],
        )

print(SampleStack().yaml())  # Generate Template

GitHubCheckoutSetting

GitHubからマスターデータをチェックアウトする設定

必須デフォルト値の制限説明
apiKeyIdstring~ 1024文字GitHub のAPIキーGRN
repositoryNamestring~ 1024文字リポジトリ名
sourcePathstring~ 1024文字ソースコードのファイルパス
referenceTypeenum {
    “commit_hash”,
    “branch”,
    “tag”
}
~ 128文字コードの取得元
commitHashstring{referenceType} == “commit_hash”~ 1024文字コミットハッシュ
branchNamestring{referenceType} == “branch”~ 1024文字ブランチ名
tagNamestring{referenceType} == “tag”~ 1024文字タグ名

referenceType に指定する列挙型の定義

定義説明
commit_hashコミットハッシュ
branchブランチ
tagタグ

LogSetting

ログの書き出し設定

ログデータの書き出し設定を管理します。この型は、ログデータを書き出すために使用されるログ名前空間の識別子(Namespace ID)を保持します。
ログ名前空間IDは、ログデータを集約し、保存する対象の GS2-Log の名前空間を指定します。
この設定を通じて、この名前空間以下のAPIリクエスト・レスポンスログデータが対象の GS2-Log へ出力されるようになります。
GS2-Log にはリアルタイムでログが提供され、システムの監視や分析、デバッグなどに利用できます。

必須デフォルト値の制限説明
loggingNamespaceIdstring~ 1024文字ネームスペースGRN

ScriptSetting

スクリプト設定

GS2 ではマイクロサービスのイベントに関連づけて、カスタムスクリプトを実行することができます。
このモデルは、スクリプトの実行をトリガーするための設定を保持します。

スクリプトの実行方式は大きく2種類あり、それは「同期実行」と「非同期実行」です。
同期実行は、スクリプトの実行が完了するまで処理がブロックされます。
かわりに、スクリプトの実行結果を使ってAPIの実行を止めたり、APIの結果を改ざんすることができます。

一方、非同期実行は、スクリプトの実行が完了するまで処理がブロックされません。
かわりに、スクリプトの実行結果を使ってAPIの実行を止めたり、APIの結果を改ざんすることはできません。
しかし、非同期実行は、スクリプトの実行が完了するまで処理がブロックされないため、APIの応答に影響を与えないため、原則非同期実行を使用することをおすすめします。

非同期実行には実行方式が2種類あり、GS2-Script と Amazon EventBridge があります。
Amazon EventBridge を使用することで、Lua 以外の言語で処理を記述することができます。

必須デフォルト値の制限説明
triggerScriptIdstring~ 1024文字スクリプトGRN
doneTriggerTargetTypeenum {
    “none”,
    “gs2_script”,
    “aws”
}
“none”~ 128文字完了通知の通知先
doneTriggerScriptIdstring{doneTriggerTargetType} == “gs2_script”~ 1024文字スクリプトGRN
doneTriggerQueueNamespaceIdstring{doneTriggerTargetType} == “gs2_script”~ 1024文字ネームスペースGRN

doneTriggerTargetType に指定する列挙型の定義

定義説明
noneなし
gs2_scriptGS2-Script
awsAmazon EventBridge