

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

# Memanggil fungsi Lambda menggunakan titik akhir Amazon API Gateway
<a name="services-apigateway"></a>

Anda dapat membuat API web dengan titik akhir HTTP untuk fungsi Lambda Anda dengan menggunakan Amazon API Gateway. API Gateway menyediakan alat untuk membuat dan mendokumentasikan web APIs yang merutekan permintaan HTTP ke fungsi Lambda. Anda dapat mengamankan akses ke API Anda dengan kontrol autentikasi dan otorisasi. Anda APIs dapat melayani lalu lintas melalui internet atau hanya dapat diakses dalam VPC 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).

Sumber daya di API Anda menentukan satu atau beberapa metode, seperti GET atau POST. Metode memiliki integrasi yang merutekan permintaan ke fungsi Lambda atau jenis integrasi lainnya. Anda dapat menentukan setiap sumber daya dan metode secara individual, atau menggunakan jenis sumber daya dan metode khusus untuk mencocokkan semua permintaan yang sesuai dengan suatu pola. [Sumber daya proksi](https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html) menangkap semua jalur di bawah sumber daya. Metode `ANY` menangkap semua metode HTTP.

**Topics**
+ [Memilih jenis API](#services-apigateway-apitypes)
+ [Menambahkan titik akhir ke fungsi Lambda Anda](#apigateway-add)
+ [Integrasi proxy](#apigateway-proxy)
+ [Format peristiwa](#apigateway-example-event)
+ [Format respons](#apigateway-types-transforms)
+ [Izin](#apigateway-permissions)
+ [Aplikasi sampel](#services-apigateway-samples)
+ [Penangan acara dari Powertools untuk Lambda AWS](#services-apigateway-powertools)
+ [Tutorial: Menggunakan Lambda dengan API Gateway](services-apigateway-tutorial.md)
+ [Menangani kesalahan Lambda dengan API Gateway API](services-apigateway-errors.md)
+ [Pilih metode untuk menjalankan fungsi Lambda Anda menggunakan permintaan HTTP](apig-http-invoke-decision.md)

## Memilih jenis API
<a name="services-apigateway-apitypes"></a>

API Gateway mendukung tiga jenis fungsi Lambda APIs yang memanggil:
+ [HTTP API: API](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api.html) ringan, latensi rendah RESTful .
+ [REST API: API](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-rest-api.html) yang dapat disesuaikan dan kaya fitur RESTful .
+ [WebSocket API: API](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-websocket-api.html) web yang memelihara koneksi persisten dengan klien untuk komunikasi dupleks penuh.

HTTP APIs dan REST APIs keduanya RESTful APIs memproses permintaan HTTP dan mengembalikan respons. HTTP APIs lebih baru dan dibangun dengan API Gateway versi 2 API. Fitur-fitur berikut ini baru untuk HTTP APIs:

**Fitur HTTP API**
+ **Deployment otomatis** – Saat Anda memodifikasi rute atau integrasi, mengubah deployment secara otomatis ke tahap yang deployment otomatisnya diaktifkan.
+ **Tahap default** – Anda dapat membuat tahap default (`$default`) untuk melayani permintaan di jalur root URL API Anda. Untuk tahap yang diberi nama, Anda harus menyertakan nama tahap di awal jalur.
+ **Konfigurasi CORS** – Anda dapat mengonfigurasi API Anda untuk menambahkan header CORS ke respons keluar, alih-alih menambahkannya secara manual dalam kode fungsi Anda.

REST APIs adalah klasik RESTful APIs yang didukung API Gateway sejak diluncurkan. REST APIs saat ini memiliki lebih banyak fitur penyesuaian, integrasi, dan manajemen.

**Fitur REST API**
+ **Jenis integrasi** - REST APIs mendukung integrasi Lambda kustom. Dengan integrasi kustom, Anda dapat mengirim hanya badan permintaan ke fungsi, atau menerapkan templat transformasi ke badan permintaan sebelum mengirimkannya ke fungsi.
+ **Kontrol akses** - REST APIs mendukung lebih banyak opsi untuk otentikasi dan otorisasi.
+ **Pemantauan dan penelusuran** — REST APIs mendukung AWS X-Ray penelusuran dan opsi pencatatan tambahan.

Untuk perbandingan mendetail, lihat [Memilih antara HTTP APIs dan REST APIs](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-vs-rest.html) di *Panduan Pengembang API Gateway*.

WebSocket APIs juga menggunakan API Gateway API versi 2 API dan mendukung set fitur serupa. Gunakan WebSocket API untuk aplikasi yang mendapat manfaat dari koneksi persisten antara klien dan API. WebSocket APIs menyediakan komunikasi dupleks penuh, yang berarti bahwa klien dan API dapat mengirim pesan terus menerus tanpa menunggu tanggapan.

HTTP APIs mendukung format acara yang disederhanakan (versi 2.0). Untuk contoh peristiwa dari API HTTP, lihat [Membuat integrasi AWS Lambda proxy untuk HTTP APIs di API Gateway](https://docs.aws.amazon.com//apigateway/latest/developerguide/http-api-develop-integrations-lambda.html).

Untuk informasi selengkapnya, lihat [Membuat integrasi AWS Lambda proxy untuk HTTP APIs di API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html).

## Menambahkan titik akhir ke fungsi Lambda Anda
<a name="apigateway-add"></a>

**Untuk menambahkan titik akhir publik ke fungsi Lambda Anda**

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

1. Pilih fungsi.

1. Di bagian **Gambaran umum fungsi**, pilih **Tambah pemicu**.

1. Pilih **API Gateway**.

1. Pilih **Buat API** atau **Gunakan API yang ada**.

   1. **API Baru:** Untuk **jenis API**, pilih **HTTP API**. Untuk informasi selengkapnya, lihat [Memilih jenis API](#services-apigateway-apitypes).

   1. **API yang ada:** Pilih API dari daftar dropdown atau masukkan ID API (misalnya, r3pmxmplak).

1. Untuk **Keamanan**, pilih **Terbuka**.

1. Pilih **Tambahkan**.

## Integrasi proxy
<a name="apigateway-proxy"></a>

API Gateway APIs terdiri dari tahapan, sumber daya, metode, dan integrasi. Tahap dan sumber daya menentukan jalur titik akhir:

**Format jalur API**
+ `/prod/` – Tahap `prod` dan sumber daya root.
+ `/prod/user` – Tahap `prod` dan sumber daya `user`.
+ `/dev/{proxy+}` – Rute mana pun di tahap `dev`.
+ `/`— (HTTP APIs) Tahap default dan sumber daya root.

Integrasi Lambda memetakan jalur dan kombinasi metode HTTP ke fungsi Lambda. Anda dapat mengonfigurasi API Gateway untuk mengirimkan badan permintaan HTTP sebagaimana adanya (integrasi kustom), atau untuk merangkum badan permintaan dalam dokumen yang mencakup semua informasi permintaan termasuk header, sumber daya, jalur, dan metode.

Untuk informasi selengkapnya, lihat [Integrasi proxy Lambda di API Gateway.](https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html)

## Format peristiwa
<a name="apigateway-example-event"></a>

Amazon API Gateway memanggil fungsi Anda [secara sinkron](invocation-sync.md) dengan kejadian yang berisi representasi JSON permintaan HTTP. Untuk integrasi kustom, kejadian adalah badan dari permintaan. Untuk integrasi proksi, kejadian memiliki struktur yang telah ditentukan. Untuk contoh peristiwa proxy dari API REST API Gateway API, lihat [Format input fungsi Lambda untuk integrasi proxy](https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html#api-gateway-simple-proxy-for-lambda-input-format) di Panduan *Pengembang API Gateway*.

## Format respons
<a name="apigateway-types-transforms"></a>

API Gateway menunggu respons dari fungsi Anda dan menyampaikan hasilnya kepada pemanggil. Untuk integrasi kustom, Anda menentukan respons integrasi dan respons metode untuk mengonversi output dari fungsi menjadi respons HTTP. Untuk integrasi proksi, fungsi harus merespons dengan representasi respons dalam format tertentu.

Contoh berikut menunjukkan objek respons dari fungsi Node.js. Objek respons mewakili respons HTTP yang berhasil yang berisi dokumen JSON.

**Example index.mjs - Objek respons integrasi proxy (Node.js)**  

```
var response = {
      "statusCode": 200,
      "headers": {
        "Content-Type": "application/json"
      },
      "isBase64Encoded": false,
      "multiValueHeaders": { 
        "X-Custom-Header": ["My value", "My other value"],
      },
      "body": "{\n  \"TotalCodeSize\": 104330022,\n  \"FunctionCount\": 26\n}"
    }
```

Runtime Lambda menyusun objek respons menjadi JSON dan mengirimkannya ke API. API menguraikan respons dan menggunakannya untuk membuat respons HTTP, yang kemudian dikirimkan ke klien yang membuat permintaan asal.

**Example Respons HTTP**  

```
< HTTP/1.1 200 OK
  < Content-Type: application/json
  < Content-Length: 55
  < Connection: keep-alive
  < x-amzn-RequestId: 32998fea-xmpl-4268-8c72-16138d629356
  < X-Custom-Header: My value
  < X-Custom-Header: My other value
  < X-Amzn-Trace-Id: Root=1-5e6aa925-ccecxmplbae116148e52f036
  <
  {
    "TotalCodeSize": 104330022,
    "FunctionCount": 26
  }
```

## Izin
<a name="apigateway-permissions"></a>

Amazon API Gateway mendapatkan izin untuk memanggil fungsi Anda dari [kebijakan berbasis sumber daya](access-control-resource-based.md) milik fungsi tersebut. Anda dapat memberikan izin invokasi kepada seluruh API, atau memberikan akses terbatas kepada suatu tahap, sumber daya, atau metode.

Saat Anda menambahkan API ke fungsi Anda dengan menggunakan konsol Lambda, menggunakan konsol API Gateway, atau dalam templat AWS SAM , kebijakan berbasis sumber daya milik fungsi tersebut akan diperbarui secara otomatis. Berikut ini adalah contoh kebijakan fungsi.

**Example kebijakan fungsi**    
****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Id": "default",
  "Statement": [
    {
      "Sid": "nodejs-apig-functiongetEndpointPermissionProd-BWDBXMPLXE2F",
      "Effect": "Allow",
      "Principal": {
        "Service": "apigateway.amazonaws.com"
      },
      "Action": "lambda:InvokeFunction",
      "Resource": "arn:aws:lambda:us-east-2:111122223333:function:nodejs-apig-function-1G3MXMPLXVXYI",
      "Condition": {
        "StringEquals": {
          "aws:SourceAccount": "111122223333"
        },
        "ArnLike": {
          "aws:SourceArn": "arn:aws:execute-api:us-east-2:111122223333:ktyvxmpls1/*/GET/"
        }
      }
    }
  ]
}
```

Anda dapat mengelola izin kebijakan fungsi secara manual dengan operasi API berikut:
+ [AddPermission](https://docs.aws.amazon.com/lambda/latest/api/API_AddPermission.html)
+ [RemovePermission](https://docs.aws.amazon.com/lambda/latest/api/API_RemovePermission.html)
+ [GetPolicy](https://docs.aws.amazon.com/lambda/latest/api/API_GetPolicy.html)

Untuk memberikan izin invokasi kepada API yang sudah ada, gunakan perintah `add-permission`. Contoh:

```
aws lambda add-permission \
  --function-name my-function \
  --statement-id apigateway-get --action lambda:InvokeFunction \
  --principal apigateway.amazonaws.com \
  --source-arn "arn:aws:execute-api:us-east-2:123456789012:mnh1xmpli7/default/GET/"
```

Anda akan melihat output berikut:

```
{
    "Statement": "{\"Sid\":\"apigateway-test-2\",\"Effect\":\"Allow\",\"Principal\":{\"Service\":\"apigateway.amazonaws.com\"},\"Action\":\"lambda:InvokeFunction\",\"Resource\":\"arn:aws:lambda:us-east-2:123456789012:function:my-function\",\"Condition\":{\"ArnLike\":{\"AWS:SourceArn\":\"arn:aws:execute-api:us-east-2:123456789012:mnh1xmpli7/default/GET\"}}}"
}
```

**catatan**  
Jika fungsi dan API Anda berbeda Wilayah AWS, pengenal Region di ARN sumber harus cocok dengan Region fungsi, bukan Region API. Saat API Gateway memanggil fungsi, ia menggunakan ARN sumber daya yang didasarkan pada ARN API, tetapi dimodifikasi agar sesuai dengan Wilayah fungsi tersebut.

ARN sumber dalam contoh ini memberikan izin ke integrasi di metode GET dari sumber daya akar di tahap default API, dengan `mnh1xmpli7` ID. Anda dapat menggunakan tanda bintang di ARN sumber untuk memberikan izin untuk beberapa tahap, metode, atau sumber daya.

**Pola sumber daya**
+ `mnh1xmpli7/*/GET/*` – Metode GET di semua sumber daya di semua tahap.
+ `mnh1xmpli7/prod/ANY/user` – Metode ANY pada sumber daya `user` di tahap `prod`.
+ `mnh1xmpli7/*/*/*` – Metode apa pun pada semua sumber daya di semua tahap.

Untuk perincian tentang melihat kebijakan dan menghapus pernyataan, lihat [Melihat kebijakan IAM berbasis sumber daya di Lambda](access-control-resource-based.md).

## Aplikasi sampel
<a name="services-apigateway-samples"></a>

[API Gateway dengan aplikasi sampel Node.js](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/nodejs-apig) menyertakan fungsi dengan AWS SAM templat yang membuat REST API yang mengaktifkan AWS X-Ray penelusuran. Ini juga mencakup skrip untuk menerapkan, menjalankan fungsi, menguji API, dan pembersihan.

## Penangan acara dari Powertools untuk Lambda AWS
<a name="services-apigateway-powertools"></a>

Event handler dari Powertools for AWS Lambda toolkit menyediakan routing, middleware, konfigurasi CORS, pembuatan spesifikasi OpenAPI, validasi permintaan, penanganan kesalahan, dan fitur berguna lainnya saat menulis fungsi Lambda yang dipanggil oleh titik akhir API Gateway (HTTP atau REST). Utilitas event handler tersedia untuk Python TypeScript dan/. JavaScript Untuk informasi selengkapnya, lihat [Event Handler REST API](https://docs.powertools.aws.dev/lambda/python/latest/core/event_handler/api_gateway/) dalam dokumentasi *Powertools for AWS Lambda (Python)* [dan Event Handler HTTP API](https://docs.aws.amazon.com/powertools/typescript/latest/features/event-handler/http/) dalam dokumentasi *Powertools* for Lambda (). AWS TypeScript

### Python
<a name="services-apigateway-powertools-python"></a>

```
from aws_lambda_powertools import Logger
from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools.utilities.typing.lambda_context import LambdaContext

app = APIGatewayRestResolver()
logger = Logger()

@app.get("/healthz")
def ping():
    return {"message": "health status ok"}

@logger.inject_lambda_context(correlation_id_path=correlation_paths.API_GATEWAY_REST)  
def lambda_handler(event: dict, context: LambdaContext) -> dict:
    return app.resolve(event, context)
```

### TypeScript
<a name="services-apigateway-powertools-typescript"></a>

```
import { Router } from '@aws-lambda-powertools/event-handler/experimental-rest';
import { Logger } from '@aws-lambda-powertools/logger';
import {
  correlationPaths,
  search,
} from '@aws-lambda-powertools/logger/correlationId';
import type { Context } from 'aws-lambda/handler';

const logger = new Logger({
  correlationIdSearchFn: search,
});

const app = new Router({ logger });

app.get("/healthz", async () => {
  return { message: "health status ok" };
});

export const handler = async (event: unknown, context: Context) => {
  // You can continue using other utilities just as before
  logger.addContext(context);
  logger.setCorrelationId(event, correlationPaths.API_GATEWAY_REST);
  return app.resolve(event, context);
};
```

# 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**.

# Menangani kesalahan Lambda dengan API Gateway API
<a name="services-apigateway-errors"></a>

API Gateway memperlakukan semua kesalahan invokasi dan fungsi sebagai kesalahan internal. Jika API Lambda menolak permintaan invokasi, API Gateway mengembalikan kode kesalahan 500. Jika fungsi berjalan, tetapi mengembalikan kesalahan atau mengembalikan respons dalam format yang salah, API Gateway mengembalikan kode 502. Dalam kedua kasus tersebut, badan respons dari API Gateway adalah `{"message": "Internal server error"}`.

**catatan**  
API Gateway tidak mencoba lagi invokasi Lambda apa pun. Jika Lambda mengembalikan kesalahan, API Gateway mengembalikan respons kesalahan ke klien.

Contoh berikut menunjukkan peta jejak X-Ray untuk permintaan yang mengakibatkan kesalahan fungsi dan 502 dari API Gateway. Klien menerima pesan kesalahan umum.

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


Untuk menyesuaikan respons kesalahan, Anda harus menangkap kesalahan dalam kode dan memformat tanggapan dalam format yang diperlukan.

**Example [index.mjs](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/nodejs-apig/function/index.mjs) - Kesalahan pemformatan**  

```
var formatError = function(error){
  var response = {
    "statusCode": error.statusCode,
    "headers": {
      "Content-Type": "text/plain",
      "x-amzn-ErrorType": error.code
    },
    "isBase64Encoded": false,
    "body": error.code + ": " + error.message
  }
  return response
}
```

API Gateway mengonversi respons ini menjadi kesalahan HTTP dengan kode dan badan status kustom. Di peta jejak, node fungsi berwarna hijau karena menangani kesalahan tersebut.

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


# Pilih metode untuk menjalankan fungsi Lambda Anda menggunakan permintaan HTTP
<a name="apig-http-invoke-decision"></a>

Banyak kasus penggunaan umum untuk Lambda melibatkan pemanggilan fungsi Anda menggunakan permintaan HTTP. Misalnya, Anda mungkin ingin aplikasi web menjalankan fungsi Anda melalui permintaan browser. Fungsi Lambda juga dapat digunakan untuk membuat REST penuh APIs, menangani interaksi pengguna dari aplikasi seluler, memproses data dari layanan eksternal melalui panggilan HTTP, atau membuat webhook khusus.

Bagian berikut menjelaskan pilihan Anda untuk memanggil Lambda melalui HTTP dan memberikan informasi untuk membantu Anda membuat keputusan yang tepat untuk kasus penggunaan khusus Anda.

## Apa pilihan Anda saat memilih metode pemanggilan HTTP?
<a name="w2aad101c29c46b9"></a>

[Lambda menawarkan dua metode utama untuk memanggil fungsi menggunakan permintaan HTTP - [fungsi](urls-configuration.md) dan API URLs Gateway.](services-apigateway.md) Perbedaan utama antara kedua opsi ini adalah sebagai berikut:
+ **Fungsi Lambda URLs** menyediakan titik akhir HTTP langsung yang sederhana untuk fungsi Lambda. Mereka dioptimalkan untuk kesederhanaan dan efektivitas biaya dan menyediakan jalur tercepat untuk mengekspos fungsi Lambda melalui HTTP.
+ **API Gateway** adalah layanan yang lebih canggih untuk membangun fitur lengkap APIs. API Gateway dioptimalkan untuk membangun dan mengelola produksi dalam APIs skala besar dan menyediakan alat komprehensif untuk keamanan, pemantauan, dan manajemen lalu lintas.

## Rekomendasi jika Anda sudah mengetahui kebutuhan Anda
<a name="w2aad101c29c46c11"></a>

Jika Anda sudah jelas tentang kebutuhan Anda, berikut adalah rekomendasi dasar kami:

Kami merekomendasikan **[fungsi URLs](urls-configuration.md)** untuk aplikasi sederhana atau prototyping di mana Anda hanya memerlukan metode otentikasi dasar dan request/response penanganan dan di mana Anda ingin meminimalkan biaya dan kompleksitas.

**[API Gateway](services-apigateway.md)** adalah pilihan yang lebih baik untuk aplikasi produksi dalam skala besar atau untuk kasus di mana Anda memerlukan fitur yang lebih canggih seperti dukungan [OpenAPI Description](https://www.openapis.org/), pilihan opsi otentikasi, nama domain khusus, atau request/response penanganan kaya termasuk throttling, caching, dan transformasi. request/response 

## Apa yang harus dipertimbangkan saat memilih metode untuk menjalankan fungsi Lambda Anda
<a name="w2aad101c29c46c13"></a>

Saat memilih antara fungsi URLs dan API Gateway, Anda perlu mempertimbangkan faktor-faktor berikut:
+ Kebutuhan otentikasi Anda, seperti apakah Anda memerlukan OAuth atau Amazon Cognito untuk mengautentikasi pengguna
+ Persyaratan penskalaan Anda dan kompleksitas API yang ingin Anda terapkan
+ Apakah Anda memerlukan fitur canggih seperti validasi permintaan dan request/response pemformatan
+ Persyaratan pemantauan Anda
+ Sasaran biaya Anda

Dengan memahami faktor-faktor ini, Anda dapat memilih opsi yang paling menyeimbangkan persyaratan keamanan, kompleksitas, dan biaya Anda.

Informasi berikut merangkum perbedaan utama antara kedua opsi.

### Autentikasi
<a name="w2aad101c29c46c13c11b1"></a>
+ **Fungsi URLs** menyediakan opsi otentikasi dasar melalui AWS Identity and Access Management (IAM). Anda dapat mengonfigurasi titik akhir Anda menjadi publik (tidak ada otentikasi) atau memerlukan otentikasi IAM. Dengan autentikasi IAM, Anda dapat menggunakan AWS kredensi standar atau peran IAM untuk mengontrol akses. Meskipun mudah diatur, pendekatan ini memberikan opsi terbatas dibandingkan dengan metode otentikat lainnya.
+ **API Gateway** menyediakan akses ke berbagai opsi otentikasi yang lebih komprehensif. Selain autentikasi IAM, Anda dapat menggunakan [otorisasi Lambda](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-use-lambda-authorizer.html) (logika otentikasi khusus), kumpulan pengguna Amazon Cognito, dan [aliran.0](https://docs.aws.amazon.com/cognito/latest/developerguide/what-is-amazon-cognito.html). OAuth2 Fleksibilitas ini memungkinkan Anda menerapkan skema otentikasi yang kompleks, termasuk penyedia otentikasi pihak ketiga, otentikasi berbasis token, dan otentikasi multi-faktor.

### Penanganan permintaan/tanggapan
<a name="w2aad101c29c46c13c11b3"></a>
+ **Fungsi URLs** menyediakan permintaan HTTP dasar dan penanganan respons. Mereka mendukung metode HTTP standar dan menyertakan dukungan berbagi sumber daya lintas asal (CORS) bawaan. Meskipun mereka dapat menangani muatan JSON dan parameter kueri secara alami, mereka tidak menawarkan transformasi permintaan atau kemampuan validasi. Penanganan respons sama mudahnya — klien menerima respons dari fungsi Lambda Anda persis seperti Lambda mengembalikannya.
+ **API Gateway** menyediakan kemampuan penanganan permintaan dan respons yang canggih. Anda dapat menentukan validator permintaan, mengubah permintaan dan tanggapan menggunakan templat pemetaan, menyiapkan request/response header, dan menerapkan cache respons. API Gateway juga mendukung payload biner dan nama domain khusus dan dapat memodifikasi tanggapan sebelum mencapai klien. Anda dapat mengatur model untuk request/response validasi dan transformasi menggunakan JSON Schema.

### Penskalaan
<a name="w2aad101c29c46c13c11b5"></a>
+  URLsSkala **fungsi** secara langsung dengan batas konkurensi fungsi Lambda Anda dan tangani lonjakan lalu lintas dengan meningkatkan fungsi Anda hingga batas konkurensi maksimum yang dikonfigurasi. Setelah batas itu tercapai, Lambda merespons permintaan tambahan dengan respons HTTP 429. Tidak ada mekanisme antrian bawaan, jadi penanganan penskalaan sepenuhnya bergantung pada konfigurasi fungsi Lambda Anda. Secara default, fungsi Lambda memiliki batas 1.000 eksekusi bersamaan per. Wilayah AWS
+ **API Gateway** menyediakan kemampuan penskalaan tambahan di atas penskalaan Lambda sendiri. Ini termasuk kontrol antrian permintaan dan pelambatan bawaan, memungkinkan Anda mengelola lonjakan lalu lintas dengan lebih anggun. API Gateway dapat menangani hingga 10.000 permintaan per detik per wilayah secara default, dengan kapasitas burst 5.000 permintaan per detik. Ini juga menyediakan alat untuk membatasi permintaan pada tingkat yang berbeda (API, panggung, atau metode) untuk melindungi backend Anda.

### Memantau
<a name="w2aad101c29c46c13c11b7"></a>
+ **Fungsi URLs** menawarkan pemantauan dasar melalui CloudWatch metrik Amazon, termasuk jumlah permintaan, latensi, dan tingkat kesalahan. Anda mendapatkan akses ke metrik dan log Lambda standar, yang menunjukkan permintaan mentah yang masuk ke fungsi Anda. Meskipun ini memberikan visibilitas operasional yang penting, metrik difokuskan terutama pada eksekusi fungsi.
+ **API Gateway** menyediakan kemampuan pemantauan komprehensif termasuk metrik terperinci, pencatatan, dan opsi penelusuran. Anda dapat memantau panggilan API, latensi, tingkat kesalahan, dan hit/miss tingkat cache melalui CloudWatch. API Gateway juga terintegrasi dengan AWS X-Ray untuk penelusuran terdistribusi dan menyediakan format logging yang dapat disesuaikan.

### Biaya
<a name="w2aad101c29c46c13c11b9"></a>
+ **Fungsi URLs** mengikuti model penetapan harga Lambda standar — Anda hanya membayar untuk pemanggilan fungsi dan waktu komputasi. Tidak ada biaya tambahan untuk titik akhir URL itu sendiri. Ini menjadikannya pilihan hemat biaya untuk aplikasi sederhana APIs atau lalu lintas rendah jika Anda tidak memerlukan fitur tambahan API Gateway.
+ **API Gateway** menawarkan [tingkat gratis](https://aws.amazon.com/api-gateway/pricing/#Free_Tier) yang mencakup satu juta panggilan API yang diterima untuk REST APIs dan satu juta panggilan API yang diterima untuk HTTP APIs. Setelah ini, API Gateway mengenakan biaya untuk panggilan API, transfer data, dan caching (jika diaktifkan). Lihat [halaman harga](https://aws.amazon.com/api-gateway/pricing/) API Gateway untuk memahami biaya untuk kasus penggunaan Anda sendiri.

### Fitur lainnya
<a name="w2aad101c29c46c13c11c11"></a>
+ **Fungsi URLs** dirancang untuk kesederhanaan dan integrasi Lambda langsung. Mereka mendukung titik akhir HTTP dan HTTPS, menawarkan dukungan CORS bawaan, dan menyediakan titik akhir dual-stack (IPv4 dan). IPv6 Meskipun mereka tidak memiliki fitur canggih, mereka unggul dalam skenario di mana Anda memerlukan cara cepat dan mudah untuk mengekspos fungsi Lambda melalui HTTP.
+ **API Gateway** mencakup banyak fitur tambahan seperti versi API, manajemen tahap, kunci API untuk rencana penggunaan, dokumentasi API melalui Swagger/OpenAPI, WebSocket APIs privat dalam VPC, dan integrasi APIs WAF untuk keamanan tambahan. Ini juga mendukung penerapan kenari, integrasi tiruan untuk pengujian, dan integrasi dengan yang lain di luar Lambda. Layanan AWS 

## Pilih metode untuk menjalankan fungsi Lambda Anda
<a name="w2aad101c29c46c15"></a>

Sekarang setelah Anda membaca tentang kriteria untuk memilih antara fungsi Lambda URLs dan API Gateway dan perbedaan utama di antara keduanya, Anda dapat memilih opsi yang paling sesuai dengan kebutuhan Anda dan menggunakan sumber daya berikut untuk membantu Anda mulai menggunakannya.

------
#### [ Function URLs ]

**Memulai dengan fungsi URLs dengan sumber daya berikut**
+ Ikuti tutorial [Membuat fungsi Lambda dengan URL fungsi](urls-webhook-tutorial.md)
+ Pelajari lebih lanjut tentang fungsi URLs [Membuat dan mengelola fungsi Lambda URLs](urls-configuration.md) di bagian panduan ini
+ Coba tutorial yang dipandu dalam konsol **Buat aplikasi web sederhana** dengan melakukan hal berikut:

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

1. Buka panel bantuan dengan memilih ikon di sudut kanan atas layar.  
![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/console_help_screenshot.png)

1. Pilih **Tutorial**.

1. Di **Buat aplikasi web sederhana**, pilih **Mulai tutorial**.

------
#### [ API Gateway ]

**Memulai Lambda dan API Gateway dengan sumber daya berikut**
+ Ikuti tutorial [Menggunakan Lambda dengan API Gateway untuk membuat REST API](services-apigateway-tutorial.md) yang terintegrasi dengan fungsi Lambda backend.
+ Pelajari selengkapnya tentang berbagai jenis API yang ditawarkan oleh API Gateway di bagian berikut dari *Panduan Pengembang Amazon API Gateway*:
  + [API Gateway REST APIs](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-rest-api.html)
  + [API Gateway HTTP APIs](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api.html)
  + [API Gateway WebSocket APIs](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-websocket-api.html)
+ Coba satu atau beberapa contoh di bagian [Tutorial dan lokakarya](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-tutorials.html) dari *Panduan Pengembang Amazon API Gateway*.

------