

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

# Tutorial: Menggunakan Lambda dengan API Gateway
<a name="services-apigateway-tutorial"></a>

Dalam tutorial ini, Anda membuat REST API di mana Anda menjalankan fungsi Lambda menggunakan permintaan HTTP. Fungsi Lambda Anda akan melakukan operasi membuat, membaca, memperbarui, dan menghapus (CRUD) pada tabel DynamoDB. Fungsi ini disediakan di sini untuk demonstrasi, tetapi Anda akan belajar mengkonfigurasi API Gateway REST API yang dapat menjalankan fungsi Lambda apa pun.

![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/APIG_tut_resources.png)


Menggunakan API Gateway memberi pengguna titik akhir HTTP yang aman untuk menjalankan fungsi Lambda Anda dan dapat membantu mengelola panggilan dalam jumlah besar ke fungsi Anda dengan membatasi lalu lintas dan secara otomatis memvalidasi dan mengotorisasi panggilan API. API Gateway juga menyediakan kontrol keamanan fleksibel menggunakan AWS Identity and Access Management (IAM) dan Amazon Cognito. Ini berguna untuk kasus penggunaan di mana otorisasi terlebih dahulu diperlukan untuk panggilan ke aplikasi Anda.

**Tip**  
Lambda menawarkan dua cara untuk menjalankan fungsi Anda melalui titik akhir HTTP: API Gateway dan fungsi Lambda. URLs Jika Anda tidak yakin metode mana yang terbaik untuk kasus penggunaan Anda, lihat[Pilih metode untuk menjalankan fungsi Lambda Anda menggunakan permintaan HTTP](apig-http-invoke-decision.md).

Untuk menyelesaikan tutorial ini, Anda akan melalui tahapan berikut:

1. Membuat dan mengkonfigurasi fungsi Lambda di Python atau Node.js untuk melakukan operasi pada tabel DynamoDB.

1. Buat REST API di API Gateway untuk terhubung ke fungsi Lambda Anda.

1. Buat tabel DynamoDB dan mengujinya dengan fungsi Lambda Anda di konsol.

1. Terapkan API Anda dan uji penyiapan lengkap menggunakan curl di terminal.

Dengan menyelesaikan tahapan ini, Anda akan mempelajari cara menggunakan API Gateway untuk membuat titik akhir HTTP yang dapat menjalankan fungsi Lambda dengan aman pada skala apa pun. Anda juga akan mempelajari cara menerapkan API Anda, dan cara mengujinya di konsol dan dengan mengirimkan permintaan HTTP menggunakan terminal.

## Membuat kebijakan izin
<a name="services-apigateway-tutorial-policy"></a>

Sebelum Anda dapat membuat [peran eksekusi](lambda-intro-execution-role.md) untuk fungsi Lambda Anda, Anda harus terlebih dahulu membuat kebijakan izin untuk memberikan izin fungsi Anda untuk mengakses sumber daya yang diperlukan. AWS Untuk tutorial ini, kebijakan memungkinkan Lambda untuk melakukan operasi CRUD pada tabel DynamoDB dan menulis ke Amazon Logs. CloudWatch 

**Untuk membuat kebijakan**

1. Buka [halaman Kebijakan](https://console.aws.amazon.com/iam/home#/policies) konsol IAM.

1. Pilih **Buat Kebijakan**.

1. Pilih tab **JSON**, lalu tempelkan kebijakan khusus berikut ke editor JSON.

------
#### [ JSON ]

****  

   ```
   {
     "Version":"2012-10-17",		 	 	 
     "Statement": [
       {
         "Sid": "Stmt1428341300017",
         "Action": [
           "dynamodb:DeleteItem",
           "dynamodb:GetItem",
           "dynamodb:PutItem",
           "dynamodb:Query",
           "dynamodb:Scan",
           "dynamodb:UpdateItem"
         ],
         "Effect": "Allow",
         "Resource": "*"
       },
       {
         "Sid": "",
         "Resource": "*",
         "Action": [
           "logs:CreateLogGroup",
           "logs:CreateLogStream",
           "logs:PutLogEvents"
         ],
         "Effect": "Allow"
       }
     ]
   }
   ```

------

1. Pilih **Berikutnya: Tanda**.

1. Pilih **Berikutnya: Tinjau**.

1. Di bawah **Kebijakan peninjauan**, untuk **Nama** kebijakan, masukkan**lambda-apigateway-policy**.

1. Pilih **Buat kebijakan**.

## Membuat peran eksekusi
<a name="services-apigateway-tutorial-role"></a>

Peran [eksekusi adalah peran](lambda-intro-execution-role.md) AWS Identity and Access Management (IAM) yang memberikan izin fungsi Lambda untuk mengakses dan sumber daya. Layanan AWS Untuk mengaktifkan fungsi Anda menjalankan operasi pada tabel DynamoDB, Anda melampirkan kebijakan izin yang Anda buat di langkah sebelumnya.

**Untuk membuat peran eksekusi dan melampirkan kebijakan izin khusus Anda**

1. Buka [halaman Peran](https://console.aws.amazon.com/iam/home#/roles) dari konsol IAM.

1. Pilih **Buat peran**.

1. Untuk jenis entitas tepercaya, pilih **AWS layanan**, lalu untuk kasus penggunaan, pilih **Lambda**.

1. Pilih **Berikutnya**.

1. Dalam kotak pencarian kebijakan, masukkan **lambda-apigateway-policy**.

1. Di hasil penelusuran, pilih kebijakan yang Anda buat (`lambda-apigateway-policy`), lalu pilih **Berikutnya**.

1. Di bawah **Rincian peran**, untuk **nama Peran**, masukkan**lambda-apigateway-role**, lalu pilih **Buat peran**.

## Buat fungsi Lambda
<a name="services-apigateway-tutorial-function"></a>

1. Buka [halaman Fungsi](https://console.aws.amazon.com/lambda/home#/functions) konsol Lambda dan pilih **Buat** Fungsi.

1. Pilih **Tulis dari awal**.

1. Untuk **Nama fungsi**, masukkan `LambdaFunctionOverHttps`.

1. Untuk **Runtime, pilih runtime** Node.js atau Python terbaru.

1. (Opsional) Di bagian **Izin**, luaskan **Ubah peran eksekusi default**.

1. Pilih **Gunakan peran yang ada**, lalu pilih **lambda-apigateway-role** peran yang Anda buat sebelumnya.

1. Pilih **Buat fungsi**.

1. Di panel **sumber Kode**, ganti kode default dengan kode Node.js atau Python berikut.

------
#### [ Node.js ]

   `region`Pengaturan harus sesuai dengan Wilayah AWS tempat Anda menyebarkan fungsi dan [membuat tabel DynamoDB](#services-apigateway-tutorial-table).

**Example index.mjs**  

   ```
   import { DynamoDBDocumentClient, PutCommand, GetCommand, 
            UpdateCommand, DeleteCommand} from "@aws-sdk/lib-dynamodb";
   import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
   
   const ddbClient = new DynamoDBClient({ region: "us-east-2" });
   const ddbDocClient = DynamoDBDocumentClient.from(ddbClient);
   
   // Define the name of the DDB table to perform the CRUD operations on
   const tablename = "lambda-apigateway";
   
   /**
    * Provide an event that contains the following keys:
    *
    *   - operation: one of 'create,' 'read,' 'update,' 'delete,' or 'echo'
    *   - payload: a JSON object containing the parameters for the table item
    *     to perform the operation on
    */
   export const handler = async (event, context) => {
      
        const operation = event.operation;
      
        if (operation == 'echo'){
             return(event.payload);
        }
        
       else { 
           event.payload.TableName = tablename;
           let response;
           
           switch (operation) {
             case 'create':
                  response = await ddbDocClient.send(new PutCommand(event.payload));
                  break;
             case 'read':
                  response = await ddbDocClient.send(new GetCommand(event.payload));
                  break;
             case 'update':
                  response = ddbDocClient.send(new UpdateCommand(event.payload));
                  break;
             case 'delete':
                  response = ddbDocClient.send(new DeleteCommand(event.payload));
                  break;
             default:
               response = 'Unknown operation: ${operation}';
             }
           console.log(response);
           return response;
       }
   };
   ```

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

**Example lambda\$1function.py**  

   ```
   import boto3
   
   # Define the DynamoDB table that Lambda will connect to
   table_name = "lambda-apigateway"
   
   # Create the DynamoDB resource
   dynamo = boto3.resource('dynamodb').Table(table_name)
   
   # Define some functions to perform the CRUD operations
   def create(payload):
       return dynamo.put_item(Item=payload['Item'])
   
   def read(payload):
       return dynamo.get_item(Key=payload['Key'])
   
   def update(payload):
       return dynamo.update_item(**{k: payload[k] for k in ['Key', 'UpdateExpression', 
       'ExpressionAttributeNames', 'ExpressionAttributeValues'] if k in payload})
   
   def delete(payload):
       return dynamo.delete_item(Key=payload['Key'])
   
   def echo(payload):
       return payload
   
   operations = {
       'create': create,
       'read': read,
       'update': update,
       'delete': delete,
       'echo': echo,
   }
   
   def lambda_handler(event, context):
       '''Provide an event that contains the following keys:
         - operation: one of the operations in the operations dict below
         - payload: a JSON object containing parameters to pass to the 
           operation being performed
       '''
       
       operation = event['operation']
       payload = event['payload']
       
       if operation in operations:
           return operations[operation](payload)
           
       else:
           raise ValueError(f'Unrecognized operation "{operation}"')
   ```

------
**catatan**  
Dalam contoh ini, nama tabel DynamoDB didefinisikan sebagai variabel dalam kode fungsi Anda. Dalam aplikasi nyata, praktik terbaik adalah meneruskan parameter ini sebagai variabel lingkungan dan untuk menghindari hardcoding nama tabel. Untuk informasi selengkapnya lihat [Menggunakan variabel AWS Lambda lingkungan](https://docs.aws.amazon.com/lambda/latest/dg/configuration-envvars.html).

1. Di bagian **DEPLOY**, pilih **Deploy** untuk memperbarui kode fungsi Anda:  
![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png)

## Uji fungsi
<a name="services-apigateway-tutorial-test-function"></a>

Sebelum mengintegrasikan fungsi Anda dengan API Gateway, konfirmasikan bahwa Anda telah berhasil menerapkan fungsi tersebut. Gunakan konsol Lambda untuk mengirim acara pengujian ke fungsi Anda.

1. Pada halaman konsol Lambda untuk fungsi Anda, pilih tab **Uji**.  
![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/test-tab.png)

1. Gulir ke bawah ke bagian **Event JSON** dan ganti acara default dengan yang berikut ini. Acara ini cocok dengan struktur yang diharapkan oleh fungsi Lambda.

   ```
   {
       "operation": "echo",
       "payload": {
           "somekey1": "somevalue1",
           "somekey2": "somevalue2"
       }
   }
   ```

1. Pilih **Uji**.

1. **Di bawah **Fungsi Eksekusi: berhasil**, perluas Detail.** Anda akan melihat tanggapan berikut:

   ```
   {
     "somekey1": "somevalue1",
     "somekey2": "somevalue2"
   }
   ```

## Membuat REST API menggunakan API Gateway
<a name="services-apigateway-tutorial-api"></a>

Pada langkah ini, Anda membuat API Gateway REST API yang akan Anda gunakan untuk menjalankan fungsi Lambda Anda.

**Untuk membuat API**

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

1. Pilih **Buat API**.

1. Di kotak **REST API**, pilih **Build**.

1. Di bawah **detail API**, biarkan **API Baru** dipilih, dan untuk **Nama API**, masukkan**DynamoDBOperations**.

1. Pilih **Buat API**.

## Buat sumber daya di REST API Anda
<a name="services-apigateway-tutorial-resource"></a>

Untuk menambahkan metode HTTP ke API Anda, Anda harus terlebih dahulu membuat sumber daya agar metode tersebut dapat dioperasikan. Di sini Anda membuat sumber daya untuk mengelola tabel DynamoDB Anda.

**Untuk membuat sumber daya**

1. Di [konsol API Gateway](https://console.aws.amazon.com/apigateway), pada halaman **Resources** untuk API Anda, pilih **Buat sumber daya**.

1. Dalam **Rincian sumber daya**, untuk **nama Sumber daya** masukkan**DynamoDBManager**.

1. Pilih **Buat Sumber Daya**.

## Buat metode HTTP POST
<a name="services-apigateway-tutorial-method"></a>

Pada langkah ini, Anda membuat metode (`POST`) untuk `DynamoDBManager` sumber daya Anda. Anda menautkan `POST` metode ini ke fungsi Lambda Anda sehingga ketika metode menerima permintaan HTTP, API Gateway memanggil fungsi Lambda Anda.

**catatan**  
 Untuk tujuan tutorial ini, satu metode HTTP (`POST`) digunakan untuk memanggil fungsi Lambda tunggal yang melakukan semua operasi pada tabel DynamoDB Anda. Dalam aplikasi nyata, praktik terbaik adalah menggunakan fungsi Lambda dan metode HTTP yang berbeda untuk setiap operasi. Untuk informasi lebih lanjut, lihat [Monolit Lambda](https://serverlessland.com/content/service/lambda/guides/aws-lambda-operator-guide/monolith) di Tanah Tanpa Server. 

**Untuk membuat metode POST**

1. Pada halaman **Resources** untuk API Anda, pastikan `/DynamoDBManager` sumber daya disorot. Kemudian, di panel **Methods**, pilih **Create method**.

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

1. Untuk **jenis Integrasi**, biarkan **fungsi Lambda dipilih**.

1. Untuk **fungsi Lambda**, pilih Amazon Resource Name (ARN) untuk function (). `LambdaFunctionOverHttps`

1. Pilih **metode Buat**.

## Membuat tabel DynamoDB
<a name="services-apigateway-tutorial-table"></a>

Buat tabel DynamoDB kosong tempat fungsi Lambda Anda akan melakukan operasi CRUD.

**Untuk membuat tabel DynamoDB**

1. Buka [halaman Tabel](https://console.aws.amazon.com/dynamodbv2#tables) di konsol DynamoDB.

1. Pilih **Buat tabel**.

1. Di bawah **Rincian tabel**, lakukan hal berikut:

   1. Untuk **Nama tabel**, masukkan **lambda-apigateway**.

   1. Untuk **kunci Partition**, masukkan**id**, dan simpan tipe data yang ditetapkan sebagai **String**.

1. Di bawah **Pengaturan tabel**, pertahankan **pengaturan Default**.

1. Pilih **Buat tabel**.

## Uji integrasi API Gateway, Lambda, dan DynamoDB
<a name="services-apigateway-tutorial-test-setup"></a>

Anda sekarang siap untuk menguji integrasi metode API Gateway API Anda dengan fungsi Lambda dan tabel DynamoDB Anda. Menggunakan konsol API Gateway, Anda mengirim permintaan langsung ke `POST` metode menggunakan fungsi pengujian konsol. Pada langkah ini, pertama-tama Anda menggunakan `create` operasi untuk menambahkan item baru ke tabel DynamoDB Anda, lalu Anda menggunakan operasi untuk `update` memodifikasi item.

**Tes 1: Untuk membuat item baru di tabel DynamoDB Anda**

1. Di [konsol API Gateway](https://console.aws.amazon.com/apigateway), pilih API (`DynamoDBOperations`) Anda.

1. Pilih metode **POST** di bawah `DynamoDBManager` sumber daya.

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

1. Di bawah **metode Test**, biarkan **string Query** dan **Header kosong.** Untuk **badan Permintaan**, tempel JSON berikut:

   ```
   {
     "operation": "create",
     "payload": {
       "Item": {
         "id": "1234ABCD",
         "number": 5
       }
     }
   }
   ```

1. Pilih **Uji**.

   Hasil yang ditampilkan saat tes selesai harus menunjukkan status`200`. Kode status ini menunjukkan bahwa `create` operasi berhasil.

    Untuk mengonfirmasi, periksa apakah tabel DynamoDB Anda sekarang berisi item baru.

1. Buka [halaman Tabel](https://console.aws.amazon.com/dynamodbv2#tables) konsol DynamoDB dan pilih tabel. `lambda-apigateway`

1. Pilih **Jelajahi item tabel**. Di panel **Item yang dikembalikan**, Anda akan melihat satu item dengan **id** `1234ABCD` dan **nomornya**`5`. Contoh:  
![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/items-returned.png)

**Tes 2: Untuk memperbarui item dalam tabel DynamoDB Anda**

1. Di [konsol API Gateway](https://console.aws.amazon.com/apigateway), kembali ke tab **Test metode POST** Anda.

1. Di bawah **metode Test**, biarkan **string Query** dan **Header kosong.** Untuk **badan Permintaan**, tempel JSON berikut:

   ```
   {
       "operation": "update",
       "payload": {
           "Key": {
               "id": "1234ABCD"
           },
           "UpdateExpression": "SET #num = :newNum",
           "ExpressionAttributeNames": {
               "#num": "number"
           },
           "ExpressionAttributeValues": {
               ":newNum": 10
           }
       }
   }
   ```

1. Pilih **Uji**.

   Hasil yang ditampilkan saat tes selesai harus menunjukkan status`200`. Kode status ini menunjukkan bahwa `update` operasi berhasil.

    Untuk mengonfirmasi, periksa apakah item di tabel DynamoDB Anda telah dimodifikasi.

1. Buka [halaman Tabel](https://console.aws.amazon.com/dynamodbv2#tables) konsol DynamoDB dan pilih tabel. `lambda-apigateway`

1. Pilih **Jelajahi item tabel**. Di panel **Item yang dikembalikan**, Anda akan melihat satu item dengan **id** `1234ABCD` dan **nomornya**`10`.  
![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/items-returned-2.png)

## Terapkan API
<a name="services-apigateway-tutorial-deploy-api"></a>

Agar klien dapat memanggil API, Anda harus membuat penerapan dan tahap terkait. Tahap mewakili snapshot API Anda termasuk metode dan integrasinya.

**Untuk menerapkan API**

1. Buka **APIs**halaman [konsol API Gateway](https://console.aws.amazon.com/apigateway) dan pilih `DynamoDBOperations` API.

1. Pada halaman **Sumber Daya** untuk API Anda, pilih **Deploy API**.

1. Untuk **Stage, pilih \$1Tahap** **baru\$1, lalu untuk **nama Stage****, masukkan. **test**

1. Pilih **Deploy**.

1. Di panel **Detail tahap**, salin URL **Panggilan.** Anda akan menggunakan ini di langkah berikutnya untuk memanggil fungsi Anda menggunakan permintaan HTTP.

## Gunakan curl untuk menjalankan fungsi Anda menggunakan permintaan HTTP
<a name="services-apigateway-tutorial-invoke-function"></a>

Anda sekarang dapat menjalankan fungsi Lambda Anda dengan mengeluarkan permintaan HTTP ke API Anda. Pada langkah ini, Anda akan membuat item baru di tabel DynamoDB Anda dan kemudian melakukan operasi baca, perbarui, dan hapus pada item tersebut.

**Untuk membuat item di tabel DynamoDB Anda menggunakan curl**

1. Buka terminal atau command prompt pada mesin lokal Anda dan jalankan `curl` perintah berikut menggunakan URL pemanggilan yang Anda salin pada langkah sebelumnya. Perintah ini menggunakan opsi berikut:
   + `-H`: Menambahkan header kustom untuk permintaan. Di sini, ia menentukan jenis konten sebagai JSON.
   + `-d`: Mengirim data di badan permintaan. Opsi ini menggunakan metode HTTP POST secara default.

------
#### [ Linux/macOS ]

   ```
   curl https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager \
   -H "Content-Type: application/json" \
   -d '{"operation": "create", "payload": {"Item": {"id": "5678EFGH", "number": 15}}}'
   ```

------
#### [ PowerShell ]

   ```
   curl.exe 'https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager' -H 'Content-Type: application/json' -d '{\"operation\": \"create\", \"payload\": {\"Item\": {\"id\": \"5678EFGH\", \"number\": 15}}}'
   ```

------

   Jika operasi berhasil, Anda akan melihat respons yang dikembalikan dengan kode status HTTP 200.

1. Anda juga dapat menggunakan konsol DynamoDB untuk memverifikasi bahwa item baru ada di tabel Anda dengan melakukan hal berikut:

   1. Buka [halaman Tabel](https://console.aws.amazon.com/dynamodbv2#tables) konsol DynamoDB dan pilih tabel. `lambda-apigateway`

   1. Pilih **Jelajahi item tabel**. Di panel **Item yang dikembalikan**, Anda akan melihat item dengan **id** `5678EFGH` dan **nomornya**`15`.

**Untuk membaca item di tabel DynamoDB Anda menggunakan curl**
+ Di terminal atau command prompt Anda, jalankan `curl` perintah berikut untuk membaca nilai item yang baru saja Anda buat. Gunakan URL pemanggilan Anda sendiri.

------
#### [ Linux/macOS ]

  ```
  curl https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager \
  -H "Content-Type: application/json" \
  -d '{"operation": "read", "payload": {"Key": {"id": "5678EFGH"}}}'
  ```

------
#### [ PowerShell ]

  ```
  curl.exe 'https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager' -H 'Content-Type: application/json' -d '{\"operation\": \"read\", \"payload\": {\"Key\": {\"id\": \"5678EFGH\"}}}'
  ```

------

  Anda akan melihat output seperti salah satu dari berikut ini tergantung pada apakah Anda memilih kode fungsi Node.js atau Python:

------
#### [ Node.js ]

  ```
  {"$metadata":{"httpStatusCode":200,"requestId":"7BP3G5Q0C0O1E50FBQI9NS099JVV4KQNSO5AEMVJF66Q9ASUAAJG",
  "attempts":1,"totalRetryDelay":0},"Item":{"id":"5678EFGH","number":15}}
  ```

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

  ```
  {"Item":{"id":"5678EFGH","number":15},"ResponseMetadata":{"RequestId":"QNDJICE52E86B82VETR6RKBE5BVV4KQNSO5AEMVJF66Q9ASUAAJG",
  "HTTPStatusCode":200,"HTTPHeaders":{"server":"Server","date":"Wed, 31 Jul 2024 00:37:01 GMT","content-type":"application/x-amz-json-1.0",
  "content-length":"52","connection":"keep-alive","x-amzn-requestid":"QNDJICE52E86B82VETR6RKBE5BVV4KQNSO5AEMVJF66Q9ASUAAJG","x-amz-crc32":"2589610852"},
  "RetryAttempts":0}}
  ```

------

**Untuk memperbarui item dalam tabel DynamoDB Anda menggunakan curl**

1. Di terminal atau command prompt Anda, jalankan `curl` perintah berikut untuk memperbarui item yang baru saja Anda buat dengan mengubah `number` nilainya. Gunakan URL pemanggilan Anda sendiri.

------
#### [ Linux/macOS ]

   ```
   curl https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager \
   -H "Content-Type: application/json" \
   -d '{"operation": "update", "payload": {"Key": {"id": "5678EFGH"}, "UpdateExpression": "SET #num = :new_value", "ExpressionAttributeNames": {"#num": "number"}, "ExpressionAttributeValues": {":new_value": 42}}}'
   ```

------
#### [ PowerShell ]

   ```
   curl.exe 'https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager' -H 'Content-Type: application/json' -d '{\"operation\": \"update\", \"payload\": {\"Key\": {\"id\": \"5678EFGH\"}, \"UpdateExpression\": \"SET #num = :new_value\", \"ExpressionAttributeNames\": {\"#num\": \"number\"}, \"ExpressionAttributeValues\": {\":new_value\": 42}}}'
   ```

------

1. Untuk mengonfirmasi bahwa nilai `number` item telah diperbarui, jalankan perintah baca lainnya:

------
#### [ Linux/macOS ]

   ```
   curl https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager \
   -H "Content-Type: application/json" \
   -d '{"operation": "read", "payload": {"Key": {"id": "5678EFGH"}}}'
   ```

------
#### [ PowerShell ]

   ```
   curl.exe 'https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager' -H 'Content-Type: application/json' -d '{\"operation\": \"read\", \"payload\": {\"Key\": {\"id\": \"5678EFGH\"}}}'
   ```

------

**Untuk menghapus item dalam tabel DynamoDB Anda menggunakan curl**

1. Di terminal atau command prompt Anda, jalankan `curl` perintah berikut untuk menghapus item yang baru saja Anda buat. Gunakan URL pemanggilan Anda sendiri.

------
#### [ Linux/macOS ]

   ```
   curl https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager \
   -H "Content-Type: application/json" \
   -d '{"operation": "delete", "payload": {"Key": {"id": "5678EFGH"}}}'
   ```

------
#### [ PowerShell ]

   ```
   curl.exe 'https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager' -H 'Content-Type: application/json' -d '{\"operation\": \"delete\", \"payload\": {\"Key\": {\"id\": \"5678EFGH\"}}}'
   ```

------

1. Konfirmasikan bahwa operasi penghapusan berhasil. Di panel **Item yang dikembalikan** dari halaman item **Jelajahi konsol** DynamoDB, verifikasi bahwa item **dengan** `5678EFGH` id tidak lagi ada di tabel.

## Bersihkan sumber daya Anda (opsional)
<a name="cleanup"></a>

Sekarang Anda dapat menghapus sumber daya yang Anda buat untuk tutorial ini, kecuali Anda ingin mempertahankannya. Dengan menghapus AWS sumber daya yang tidak lagi Anda gunakan, Anda mencegah tagihan yang tidak perlu ke Anda Akun AWS.

**Untuk menghapus fungsi Lambda**

1. Buka [halaman Fungsi](https://console.aws.amazon.com/lambda/home#/functions) di konsol Lambda.

1. Pilih fungsi yang Anda buat.

1. Pilih **Tindakan**, **Hapus**.

1. Ketik **confirm** kolom input teks dan pilih **Hapus**.

**Untuk menghapus peran eksekusi**

1. Buka [halaman Peran](https://console.aws.amazon.com/iam/home#/roles) dari konsol IAM.

1. Pilih peran eksekusi yang Anda buat.

1. Pilih **Hapus**.

1. Masukkan nama peran di bidang input teks dan pilih **Hapus**.

**Untuk menghapus API**

1. Buka [halaman APIs ](https://console.aws.amazon.com/apigateway/main/apis) di konsol API Gateway.

1. Pilih API yang Anda buat.

1. Pilih **Tindakan**, **Hapus**.

1. Pilih **Hapus**.

**Untuk menghapus tabel DynamoDB**

1. Buka [halaman Tabel](https://console.aws.amazon.com//dynamodb/home#tables:) di konsol DynamoDB.

1. Pilih tabel yang Anda buat.

1. Pilih **Hapus**.

1. Masukkan **delete** di kotak teks.

1. Pilih **Hapus tabel**.