Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Menggunakan AWS CDK untuk membuat alur kerja Express di Step Functions
<a name="tutorial-step-functions-rest-api-integration-cdk"></a>

Dalam tutorial ini, Anda mempelajari cara membuat API Gateway REST API dengan mesin status ekspres sinkron sebagai integrasi backend, menggunakan kerangka AWS Cloud Development Kit (AWS CDK) Infrastructure as Code (IAC).

Anda akan menggunakan `StepFunctionsRestApi` konstruksi untuk menghubungkan State Machine ke API Gateway. `StepFunctionsRestApi`Konstruksi akan menyiapkan input/output pemetaan default dan API Gateway REST API, dengan izin yang diperlukan dan metode HTTP “APAPUN”.

 Dengan AWS CDK kerangka Infrastructure as Code (IAC), Anda mendefinisikan AWS infrastruktur menggunakan bahasa pemrograman. Anda menentukan aplikasi dalam salah satu bahasa yang didukung CDK, mensintesis kode ke dalam CloudFormation templat, dan kemudian menerapkan infrastruktur ke akun Anda. AWS 

 Anda akan menggunakan CloudFormation untuk mendefinisikan API Gateway REST API, yang terintegrasi dengan Synchronous Express State Machine sebagai backend, lalu gunakan Konsol Manajemen AWS untuk memulai eksekusi. 

Sebelum memulai tutorial ini, siapkan lingkungan AWS CDK pengembangan Anda seperti yang dijelaskan dalam [Memulai Dengan AWS CDK - Prasyarat](https://docs.aws.amazon.com/cdk/latest/guide/getting_started.html#getting_started_prerequisites), lalu instal dengan menerbitkan: AWS CDK 

```
npm install -g aws-cdk
```

## Langkah 1: Siapkan AWS CDK Proyek Anda
<a name="step-functions-rest-api-integration-cdk-step-1"></a>

Pertama, buat direktori untuk AWS CDK aplikasi baru Anda dan inisialisasi proyek.

------
#### [ TypeScript ]

```
mkdir stepfunctions-rest-api
cd stepfunctions-rest-api
cdk init --language typescript
```

------
#### [ JavaScript ]

```
mkdir stepfunctions-rest-api
cd stepfunctions-rest-api
cdk init --language javascript
```

------
#### [ Python ]

```
mkdir stepfunctions-rest-api
cd stepfunctions-rest-api
cdk init --language python
```

Setelah proyek diinisialisasi, aktifkan lingkungan virtual proyek dan instal AWS CDK dependensi dasar.

```
source .venv/bin/activate
python -m pip install -r requirements.txt
```

------
#### [ Java ]

```
mkdir stepfunctions-rest-api
cd stepfunctions-rest-api
cdk init --language java
```

------
#### [ C\$1 ]

```
mkdir stepfunctions-rest-api
cd stepfunctions-rest-api
cdk init --language csharp
```

------
#### [ Go ]

```
mkdir stepfunctions-rest-api
cd stepfunctions-rest-api
cdk init --language go
```

------

**catatan**  
Pastikan untuk memberi nama `stepfunctions-rest-api` direktori. Templat aplikasi AWS CDK menggunakan nama direktori untuk membuat nama untuk file sumber dan kelas. Jika Anda menggunakan nama yang berbeda, aplikasi Anda tidak akan cocok dengan tutorial ini.

Sekarang instal modul pustaka konstruksi untuk AWS Step Functions dan Amazon API Gateway.

------
#### [ TypeScript ]

```
npm install @aws-cdk/aws-stepfunctions @aws-cdk/aws-apigateway
```

------
#### [ JavaScript ]

```
npm install @aws-cdk/aws-stepfunctions @aws-cdk/aws-apigateway
```

------
#### [ Python ]

```
python -m pip install aws-cdk.aws-stepfunctions
python -m pip install aws-cdk.aws-apigateway
```

------
#### [ Java ]

Edit `pom.xml` proyek untuk menambahkan dependensi berikut di dalam kontainer `<dependencies>` yang sudah ada.

```
        <dependency>
            <groupId>software.amazon.awscdk</groupId>
            <artifactId>stepfunctions</artifactId>
            <version>${cdk.version}</version>
        </dependency>
        <dependency>
            <groupId>software.amazon.awscdk</groupId>
            <artifactId>apigateway</artifactId>
            <version>${cdk.version}</version>
        </dependency>
```

Maven menginstal dependensi ini secara otomatis saat Anda membangun aplikasi berikutnya. Untuk membangun, terbitkan `mvn compile` atau gunakan perintah **Bangun** IDE Java Anda.

------
#### [ C\$1 ]

```
dotnet add src/StepfunctionsRestApi package Amazon.CDK.AWS.Stepfunctions
dotnet add src/StepfunctionsRestApi package Amazon.CDK.AWS.APIGateway
```

Anda juga dapat menginstal paket yang ditunjukkan menggunakan NuGet GUI Visual Studio, tersedia melalui **Tools** > **NuGet Package Manager > Manage NuGet Packages** **for Solution**.

------

Setelah menginstal modul, Anda dapat menggunakannya di AWS CDK aplikasi Anda dengan mengimpor paket-paket berikut.

------
#### [ TypeScript ]

```
@aws-cdk/aws-stepfunctions
@aws-cdk/aws-apigateway
```

------
#### [ JavaScript ]

```
@aws-cdk/aws-stepfunctions
@aws-cdk/aws-apigateway
```

------
#### [ Python ]

```
aws_cdk.aws_stepfunctions
aws_cdk.aws_apigateway
```

------
#### [ Java ]

```
software.amazon.awscdk.services.apigateway.StepFunctionsRestApi
software.amazon.awscdk.services.stepfunctions.Pass
software.amazon.awscdk.services.stepfunctions.StateMachine
software.amazon.awscdk.services.stepfunctions.StateMachineType
```

------
#### [ C\$1 ]

```
Amazon.CDK.AWS.StepFunctions
Amazon.CDK.AWS.APIGateway
```

------
#### [ Go ]

Tambahkan yang berikut ini ke `import` dalam`stepfunctions-rest-api.go`.

```
"github.com/aws/aws-cdk-go/awscdk/awsapigateway"
"github.com/aws/aws-cdk-go/awscdk/awsstepfunctions"
```

------

## Langkah 2: Gunakan AWS CDK untuk membuat API Gateway REST API dengan integrasi backend Synchronous Express State Machine
<a name="step-functions-rest-api-integration-cdk-step-2"></a>

Pertama, kami akan menyajikan potongan kode individual yang mendefinisikan Synchronous Express State Machine dan API Gateway REST API, lalu menjelaskan cara menyatukannya ke dalam AWS CDK aplikasi Anda. Kemudian Anda akan melihat cara mensintesis dan men-deploy sumber daya ini.

**catatan**  
Mesin Negara yang akan kami tunjukkan di sini akan menjadi Mesin Negara sederhana dengan `Pass` status.

### Untuk membuat Mesin Negara Ekspres
<a name="step-functions-rest-api-integration-cdk-create-state-machine"></a>

Ini adalah AWS CDK kode yang mendefinisikan mesin negara sederhana dengan `Pass` status.

------
#### [ TypeScript ]

```
const machineDefinition = new stepfunctions.Pass(this, 'PassState', {
    result: {value:"Hello!"},
})

const stateMachine = new stepfunctions.StateMachine(this, 'MyStateMachine', {
    definition: machineDefinition,
    stateMachineType: stepfunctions.StateMachineType.EXPRESS,
});
```

------
#### [ JavaScript ]

```
const machineDefinition = new sfn.Pass(this, 'PassState', {
    result: {value:"Hello!"},
})

const stateMachine = new sfn.StateMachine(this, 'MyStateMachine', {
    definition: machineDefinition,
    stateMachineType: stepfunctions.StateMachineType.EXPRESS,
});
```

------
#### [ Python ]

```
machine_definition = sfn.Pass(self,"PassState", 
                        result = sfn.Result("Hello"))
    
state_machine = sfn.StateMachine(self, 'MyStateMachine', 
        definition = machine_definition, 
        state_machine_type = sfn.StateMachineType.EXPRESS)
```

------
#### [ Java ]

```
Pass machineDefinition = Pass.Builder.create(this, "PassState")
                        .result(Result.fromString("Hello"))
                        .build();

StateMachine stateMachine = StateMachine.Builder.create(this, "MyStateMachine")
                            .definition(machineDefinition)
                            .stateMachineType(StateMachineType.EXPRESS)
                            .build();
```

------
#### [ C\$1 ]

```
var machineDefinition = new Pass(this, "PassState", new PassProps
{
    Result = Result.FromString("Hello")
});

var stateMachine = new StateMachine(this, "MyStateMachine", new StateMachineProps
{
    Definition = machineDefinition,
    StateMachineType = StateMachineType.EXPRESS
});
```

------
#### [ Go ]

```
var machineDefinition = awsstepfunctions.NewPass(stack, jsii.String("PassState"), &awsstepfunctions.PassProps
{
    Result: awsstepfunctions.NewResult(jsii.String("Hello")),
})

var stateMachine = awsstepfunctions.NewStateMachine(stack, jsii.String("StateMachine"), &awsstepfunctions.StateMachineProps
{    
    Definition: machineDefinition,
    StateMachineType: awsstepfunctions.StateMachineType_EXPRESS,
})
```

------

Anda dapat melihat dalam cuplikan singkat ini:
+ Definisi mesin bernama`PassState`, yang merupakan `Pass` Negara.
+ Nama logis dari State Machine, `MyStateMachine`
+ Definisi mesin digunakan sebagai definisi State Machine.
+ Jenis Mesin Negara diatur sebagai `EXPRESS` karena hanya `StepFunctionsRestApi` akan mengizinkan mesin status Synchronous Express.

### Untuk membuat API API Gateway REST API menggunakan `StepFunctionsRestApi` build
<a name="step-functions-rest-api-integration-cdk-create-rest-api"></a>

Kami akan menggunakan `StepFunctionsRestApi` konstruksi untuk membuat API Gateway REST API dengan izin yang diperlukan dan pemetaan default input/output .

------
#### [ TypeScript ]

```
const api = new apigateway.StepFunctionsRestApi(this, 
  'StepFunctionsRestApi', { stateMachine: stateMachine });
```

------
#### [ JavaScript ]

```
const api = new apigateway.StepFunctionsRestApi(this, 
  'StepFunctionsRestApi', { stateMachine: stateMachine });
```

------
#### [ Python ]

```
api = apigw.StepFunctionsRestApi(self, "StepFunctionsRestApi",
                            state_machine = state_machine)
```

------
#### [ Java ]

```
StepFunctionsRestApi api = StepFunctionsRestApi.Builder.create(this, "StepFunctionsRestApi")
                           .stateMachine(stateMachine)
                           .build();
```

------
#### [ C\$1 ]

```
var api = new StepFunctionsRestApi(this, "StepFunctionsRestApi", new StepFunctionsRestApiProps
{
    StateMachine = stateMachine
});
```

------
#### [ Go ]

```
awsapigateway.NewStepFunctionsRestApi(stack, jsii.String("StepFunctionsRestApi"), &awsapigateway.StepFunctionsRestApiProps
{
    StateMachine = stateMachine,
})
```

------

### Untuk membangun dan menerapkan aplikasi AWS CDK
<a name="step-functions-rest-api-integration-cdk-app"></a>

Dalam AWS CDK proyek yang Anda buat, edit file yang berisi definisi tumpukan agar terlihat seperti kode di bawah ini. Anda akan mengenali definisi mesin status Step Functions dan API Gateway dari atas.

------
#### [ TypeScript ]

Perbarui ` lib/stepfunctions-rest-api-stack.ts` untuk membaca sebagai berikut.

```
import * as cdk from 'aws-cdk-lib';
import * as stepfunctions from 'aws-cdk-lib/aws-stepfunctions' 
import * as apigateway from 'aws-cdk-lib/aws-apigateway';


export class StepfunctionsRestApiStack extends cdk.Stack {
    constructor(scope: cdk.App, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    const machineDefinition = new stepfunctions.Pass(this, 'PassState', {
        result: {value:"Hello!"},
    });
    
    const stateMachine = new stepfunctions.StateMachine(this, 'MyStateMachine', {
        definition: machineDefinition,
        stateMachineType: stepfunctions.StateMachineType.EXPRESS,
    });
    
    const api = new apigateway.StepFunctionsRestApi(this, 
        'StepFunctionsRestApi', { stateMachine: stateMachine });
```

------
#### [ JavaScript ]

Perbarui `lib/stepfunctions-rest-api-stack.js` untuk membaca sebagai berikut.

```
const cdk = require('@aws-cdk/core');
const stepfunctions = require('@aws-cdk/aws-stepfunctions');
const apigateway = require('@aws-cdk/aws-apigateway');


class StepfunctionsRestApiStack extends cdk.Stack {
    constructor(scope: cdk.Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    const machineDefinition = new stepfunctions.Pass(this, "PassState", {
        result: {value:"Hello!"},
    })
    
    const stateMachine = new sfn.StateMachine(this, 'MyStateMachine', {
        definition: machineDefinition,
        stateMachineType: stepfunctions.StateMachineType.EXPRESS,
    });
    
    const api = new apigateway.StepFunctionsRestApi(this, 
        'StepFunctionsRestApi', { stateMachine: stateMachine });

    }
}

module.exports = { StepStack }
```

------
#### [ Python ]

Perbarui `stepfunctions_rest_api/stepfunctions_rest_api_stack.py` untuk membaca sebagai berikut.

```
from aws_cdk import App, Stack
from constructs import Construct
from aws_cdk import aws_stepfunctions as sfn
from aws_cdk import aws_apigateway as apigw

class StepfunctionsRestApiStack(Stack):

    def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
        super().__init__(scope, construct_id, **kwargs)
        
        
        machine_definition = sfn.Pass(self,"PassState", 
                                result = sfn.Result("Hello"))

        state_machine = sfn.StateMachine(self, 'MyStateMachine', 
                definition = machine_definition, 
                state_machine_type = sfn.StateMachineType.EXPRESS)

        api = apigw.StepFunctionsRestApi(self, 
                    "StepFunctionsRestApi",
                    state_machine = state_machine)
```

------
#### [ Java ]

Perbarui `src/main/java/com.myorg/StepfunctionsRestApiStack.java` untuk membaca sebagai berikut.

```
package com.myorg;


import software.amazon.awscdk.core.Construct;
import software.amazon.awscdk.core.Stack;
import software.amazon.awscdk.core.StackProps;
import software.amazon.awscdk.services.stepfunctions.Pass;
import software.amazon.awscdk.services.stepfunctions.StateMachine;
import software.amazon.awscdk.services.stepfunctions.StateMachineType;
import software.amazon.awscdk.services.apigateway.StepFunctionsRestApi;

public class StepfunctionsRestApiStack extends Stack {
    public StepfunctionsRestApiStack(final Construct scope, final String id) {
        this(scope, id, null);
    }

    public StepfunctionsRestApiStack(final Construct scope, final String id, final StackProps props) {
        super(scope, id, props);

        Pass machineDefinition = Pass.Builder.create(this, "PassState")
                                .result(Result.fromString("Hello"))
                                .build();
        
        StateMachine stateMachine = StateMachine.Builder.create(this, "MyStateMachine")
                                    .definition(machineDefinition)
                                    .stateMachineType(StateMachineType.EXPRESS)
                                    .build();
                                    
        StepFunctionsRestApi api = StepFunctionsRestApi.Builder.create(this, "StepFunctionsRestApi")
                                   .stateMachine(stateMachine)
                                   .build();
                                   
    }
}
```

------
#### [ C\$1 ]

Perbarui `src/StepfunctionsRestApi/StepfunctionsRestApiStack.cs` untuk membaca sebagai berikut.

```
using Amazon.CDK;
using Amazon.CDK.AWS.StepFunctions;
using Amazon.CDK.AWS.APIGateway;

namespace StepfunctionsRestApi
{
    public class StepfunctionsRestApiStack : Stack
    {
        internal StepfunctionsRestApi(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
        {
            var machineDefinition = new Pass(this, "PassState", new PassProps
            {
                Result = Result.FromString("Hello")
            });

            var stateMachine = new StateMachine(this, "MyStateMachine", new StateMachineProps
            {
                Definition = machineDefinition,
                StateMachineType = StateMachineType.EXPRESS
            });
            
            var api = new StepFunctionsRestApi(this, "StepFunctionsRestApi", new StepFunctionsRestApiProps
            {
                StateMachine = stateMachine
            });

        }
    }
}
```

------
#### [ Go ]

Perbarui `stepfunctions-rest-api.go` untuk membaca sebagai berikut.

```
package main
import (
    "github.com/aws/aws-cdk-go/awscdk"
    "github.com/aws/aws-cdk-go/awscdk/awsapigateway"
    "github.com/aws/aws-cdk-go/awscdk/awsstepfunctions"
    "github.com/aws/constructs-go/constructs/v3"
    "github.com/aws/jsii-runtime-go"
)


type StepfunctionsRestApiGoStackProps struct {
    awscdk.StackProps
}

func NewStepfunctionsRestApiGoStack(scope constructs.Construct, id string, props *StepfunctionsRestApiGoStackProps) awscdk.Stack {
    var sprops awscdk.StackProps
    if props != nil {
        sprops = props.StackProps
    }
    stack := awscdk.NewStack(scope, &id, &sprops)

    // The code that defines your stack goes here
    var machineDefinition = awsstepfunctions.NewPass(stack, jsii.String("PassState"), &awsstepfunctions.PassProps
    {
        Result: awsstepfunctions.NewResult(jsii.String("Hello")),
    })

    var stateMachine = awsstepfunctions.NewStateMachine(stack, jsii.String("StateMachine"), &awsstepfunctions.StateMachineProps{
        Definition: machineDefinition,
        StateMachineType: awsstepfunctions.StateMachineType_EXPRESS,
    });

    awsapigateway.NewStepFunctionsRestApi(stack, jsii.String("StepFunctionsRestApi"), &awsapigateway.StepFunctionsRestApiProps{
        StateMachine = stateMachine,
    })

    return stack
}

func main() {
    app := awscdk.NewApp(nil)

    NewStepfunctionsRestApiGoStack(app, "StepfunctionsRestApiGoStack", &StepfunctionsRestApiGoStackProps{
        awscdk.StackProps{
            Env: env(),
        },
    })

    app.Synth(nil)
}

// env determines the AWS environment (account+region) in which our stack is to
// be deployed. For more information see: https://docs.aws.amazon.com/cdk/latest/guide/environments.html
func env() *awscdk.Environment {
    // If unspecified, this stack will be "environment-agnostic".
    // Account/Region-dependent features and context lookups will not work, but a
    // single synthesized template can be deployed anywhere.
    //---------------------------------------------------------------------------
    return nil

    // Uncomment if you know exactly what account and region you want to deploy
    // the stack to. This is the recommendation for production stacks.
    //---------------------------------------------------------------------------
    // return &awscdk.Environment{
    //  Account: jsii.String("account-id"),
    //  Region:  jsii.String("us-east-1"),
    // }

    // Uncomment to specialize this stack for the AWS Account and Region that are
    // implied by the current CLI configuration. This is recommended for dev
    // stacks.
    //---------------------------------------------------------------------------
    // return &awscdk.Environment{
    //  Account: jsii.String(os.Getenv("CDK_DEFAULT_ACCOUNT")),
    //  Region:  jsii.String(os.Getenv("CDK_DEFAULT_REGION")),
    // }
}
```

------

Simpan file sumber, lalu terbitkan `cdk synth` di direktori utama aplikasi. AWS CDK Menjalankan aplikasi dan mensintesis CloudFormation template darinya, lalu menampilkan template.

Untuk benar-benar menerapkan Amazon API Gateway dan mesin AWS Step Functions status ke akun AWS Anda, masalah`cdk deploy`. Anda akan diminta untuk menyetujui kebijakan IAM yang AWS CDK telah dihasilkan.

## Langkah 3: Uji API Gateway
<a name="step-functions-rest-api-integration-cdk-step-3"></a>

Setelah Anda membuat API Gateway REST API dengan Synchronous Express State Machine sebagai integrasi backend, Anda dapat menguji API Gateway.

### Untuk menguji API Gateway yang diterapkan menggunakan konsol API Gateway
<a name="to-test-the-deployed-api-gateway-using-console"></a>

1. Buka [konsol Amazon API Gateway](https://console.aws.amazon.com/apigateway/) dan masuk.

1. Pilih REST API Anda bernama`StepFunctionsRestApi`.

1. Di panel **Resources**, pilih `ANY` metode.

1. Pilih tab **Uji**. Anda mungkin perlu memilih tombol panah kanan untuk menampilkan tab. 

1. Untuk **Metode**, pilih **POST**.

1. Untuk **badan Permintaan**, salin parameter permintaan berikut.

   ```
   {
       "key": "Hello"
   }
   ```

1. Pilih **Uji**. Informasi berikut akan ditampilkan:
   + **Permintaan** adalah jalur sumber daya yang dipanggil untuk metode. 
   + **Status** adalah kode status HTTP respon.
   + **Latensi** adalah waktu antara penerimaan permintaan dari penelepon dan respons yang dikembalikan.
   + **Response body** adalah badan respon HTTP.
   + **Response header** adalah header respon HTTP.
   + **Log** menunjukkan simulasi entri Amazon CloudWatch Logs yang akan ditulis jika metode ini dipanggil di luar konsol API Gateway.
**catatan**  
Meskipun entri CloudWatch Log disimulasikan, hasil pemanggilan metode adalah nyata.

Output **tubuh Response** harus seperti ini:

```
"Hello"
```

**Tip**  
Coba API Gateway dengan metode yang berbeda dan input yang tidak valid untuk melihat keluaran kesalahan. Anda mungkin ingin mengubah mesin status untuk mencari kunci tertentu dan selama pengujian memberikan kunci yang salah untuk gagal eksekusi State Machine dan menghasilkan pesan kesalahan dalam output **badan Response**.

### Untuk menguji API yang diterapkan menggunakan cURL
<a name="to-test-the-deployed-api-gateway-using-curl"></a>

1. Buka jendela terminal.

1. Salin perintah cURL berikut dan tempelkan ke jendela terminal, ganti `<api-id>` dengan API ID API Anda dan `<region>` dengan wilayah tempat API Anda digunakan. 

   ```
   curl -X POST\
    'https://<api-id>.execute-api.<region>.amazonaws.com/prod' \
    -d '{"key":"Hello"}' \
    -H 'Content-Type: application/json'
   ```

Output **Response Body** harus seperti ini:

```
"Hello"
```

**Tip**  
Coba API Gateway dengan metode yang berbeda dan input yang tidak valid untuk melihat keluaran kesalahan. Anda mungkin ingin mengubah mesin status untuk mencari kunci tertentu dan selama pengujian memberikan kunci yang salah untuk gagal eksekusi State Machine dan menghasilkan pesan kesalahan dalam output **Response Body**.

## Langkah 4: Bersihkan
<a name="step-functions-rest-api-integration-cdk-step-4"></a>

Setelah selesai mencoba API Gateway, Anda dapat meruntuhkan mesin status dan API Gateway menggunakan AWS CDK. Terbitkan `cdk destroy` di direktori utama aplikasi Anda.