

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 yang melaluinya Anda memanggil fungsi Lambda menggunakan permintaan HTTP. Fungsi Lambda Anda melakukan operasi membuat, membaca, memperbarui, dan menghapus (CRUD) pada tabel DynamoDB. Fungsi ini disediakan di sini untuk demonstrasi, tetapi Anda belajar mengkonfigurasi API Gateway REST API yang dapat memanggil fungsi Lambda apa pun.

![Layanan dan sumber daya yang digunakan dalam tutorial ini.](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 memanggil fungsi Lambda Anda dan dapat membantu mengelola volume besar panggilan ke fungsi Anda dengan membatasi lalu lintas dan secara otomatis memvalidasi dan mengotorisasi panggilan API. API Gateway juga menyediakan kontrol keamanan yang fleksibel menggunakan AWS Identity and Access Management (IAM) dan Amazon Cognito. Ini berguna untuk kasus penggunaan di mana otorisasi di muka diperlukan untuk panggilan ke aplikasi Anda.

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

Untuk menyelesaikan tutorial ini, Anda melalui tahapan berikut:

1. Buat dan konfigurasikan 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 uji dengan fungsi Lambda Anda di konsol.

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

Dengan menyelesaikan tahapan ini, Anda mempelajari cara menggunakan API Gateway untuk membuat titik akhir HTTP yang dapat dengan aman memanggil fungsi Lambda pada skala apa pun. Anda juga mempelajari cara menerapkan API Anda, dan cara mengujinya di konsol dan dengan mengirim 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 harus terlebih dahulu membuat kebijakan izin untuk memberikan izin fungsi untuk mengakses AWS sumber daya yang diperlukan. Untuk tutorial ini, kebijakan memungkinkan Lambda 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 tempel kebijakan kustom 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 T ** injauan, untuk ** Nama kebijakan**, masukkan**lambda-apigateway-policy**.

1. Pilih **Buat kebijakan**.

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

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

**Untuk membuat peran eksekusi dan melampirkan kebijakan izin kustom 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 Ber ** ikutnya**.

1. Di bawah Detail ** 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 [ Functions pada ](https://console.aws.amazon.com/lambda/home#/functions) konsol Lambda dan pilih ** Create Func ** tion.

1. Pilih **Tulis dari awal**.

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

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

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 berikut Node.js atau Python.

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

   Peng `region` aturan harus sesuai dengan Wilayah AWS tempat Anda menerapkan 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\_function.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 ** De ** ploy untuk memperbarui kode fungsi Anda:  
![Menyebarkan tombol di editor kode konsol Lambda](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 ** Tes.  
![Tab Uji konsol Lambda.](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. Peristiwa 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"
   }
   ```

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

Pada langkah ini, Anda membuat API Gateway REST API yang Anda gunakan untuk memanggil 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 ** Sumber daya untuk API Anda, pilih ** Buat sumber daya**.

1. Di ** Detail 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 yang berbeda dan metode HTTP untuk setiap operasi. Untuk informasi lebih lanjut, lihat [ Monolit Lambda ](https://serverlessland.com/content/service/lambda/guides/aws-lambda-operator-guide/monolith) di Serverless Land. 

**Untuk membuat metode POST**

1. Pada ** halaman ** Resources untuk API Anda, pastikan bahwa `/DynamoDBManager` sumber daya disorot. Kemudian, di ** panel ** Metode, pilih ** Buat metode**.

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

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

1. Untuk fungsi ** Lambda**, pilih Nama Sumber Daya Amazon (ARN) untuk fungsi Anda (`LambdaFunctionOverHttps`).

1. Pilih Metode ** Buat**.

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

Buat tabel DynamoDB kosong tempat fungsi Lambda Anda 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 Detail ** Tabel**, lakukan hal berikut:

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

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

1. Di bawah ** Pengaturan tabel**, pertahankan pengaturan Def ** ault**.

1. Pilih **Buat tabel**.

## Menguji 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 Anda menggunakan fungsi pengujian konsol. Pada langkah ini, pertama-tama Anda menggunakan `create` operasi untuk menambahkan item baru ke tabel DynamoDB Anda, kemudian Anda menggunakan `update` operasi untuk 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`).

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

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

1. Di bawah Metode ** pengujian**, biarkan string ** kueri ** dan ** Header ** kosong. Untuk ** isi 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 [https://console.aws.amazon.com/dynamodbv2#tables](https://console.aws.amazon.com/dynamodbv2#tables) Tabel konsol DynamoDB dan pilih tabel. `lambda-apigateway`

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

**Tes 2: Untuk memperbarui item di 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 ** pengujian**, biarkan string ** kueri ** dan ** Header ** kosong. Untuk ** isi 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 dalam tabel DynamoDB Anda telah dimodifikasi.

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

1. Memilih ** Jelajahi item tabel**. Di ** panel I ** tem dikembalikan, Anda akan melihat satu item dengan ** id ** `1234ABCD` dan ** nomornya **`10`.  
![Item uji diubah menjadi nomor 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 ** halaman ** API pada konsol [ API Gateway ](https://console.aws.amazon.com/apigateway) dan pilih `DynamoDBOperations` API.

1. Pada ** halaman ** Resources untuk API Anda pilih De ** ploy API**.

1. Untuk T ** aha ** p, pilih ** \*Tahap baru\***, lalu untuk Nama pang ** gung**, masukkan. **test**

1. Pilih **Deploy**.

1. Di ** panel rincian St ** age, salin URL ** ** Invoke. Anda menggunakan ini pada langkah berikutnya untuk memanggil fungsi Anda menggunakan permintaan HTTP.

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

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

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

1. Buka terminal atau command prompt pada mesin lokal Anda dan jalankan `curl` perintah berikut menggunakan URL invoke yang Anda salin pada langkah sebelumnya. Perintah ini menggunakan opsi berikut:
   + `-H`: Menambahkan header kustom ke permintaan. Di sini, ini menentukan jenis konten sebagai JSON.
   + `-d`: Mengirim data dalam 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 [https://console.aws.amazon.com/dynamodbv2#tables](https://console.aws.amazon.com/dynamodbv2#tables) Tabel konsol DynamoDB dan pilih tabel. `lambda-apigateway`

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

**Untuk membaca item di tabel DynamoDB 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 di 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 nil `number` ainya. 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` untuk item telah diperbarui, jalankan perintah baca lain:

------
#### [ 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 di tabel DynamoDB 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 I ** tem yang dikembalikan dari ** halaman ** Jelajahi item konsol DynamoDB, verifikasi bahwa item dengan ** id tidak lagi ** `5678EFGH` 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 biaya yang tidak perlu kepada 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** di bidang input teks dan pilih H ** apus**.

**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 H ** apus**.

**Untuk menghapus API**

1. Buka [halaman API](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**.

Jika Anda mengalami kesalahan saat memanggil fungsi Anda melalui API Gateway, lihat[Menangani kesalahan Lambda dengan API Gateway API](services-apigateway-errors.md).