Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Kontrol dan kelola akses ke HTTP APIs di API Gateway
API Gateway mendukung beberapa mekanisme untuk mengontrol dan mengelola akses ke HTTP API Anda:
+ **Otorisasi Lambda menggunakan** fungsi Lambda untuk mengontrol akses ke. APIs Untuk informasi selengkapnya, lihat [Kontrol akses ke HTTP APIs dengan AWS Lambda otorisasi](http-api-lambda-authorizer.md).
+ **Authorizer JWT** menggunakan token web JSON untuk mengontrol akses ke. APIs Untuk informasi selengkapnya, lihat [Kontrol akses ke HTTP APIs dengan otorisasi JWT di API Gateway](http-api-jwt-authorizer.md).
+ **Peran dan kebijakan AWS IAM standar** menawarkan kontrol akses yang fleksibel dan kuat. Anda dapat menggunakan peran dan kebijakan IAM untuk mengontrol siapa yang dapat membuat dan mengelola Anda APIs, serta siapa yang dapat memanggilnya. Untuk informasi selengkapnya, lihat [Kontrol akses ke HTTP APIs dengan otorisasi IAM di API Gateway](http-api-access-control-iam.md).
Untuk meningkatkan postur keamanan Anda, kami sarankan Anda mengonfigurasi otorisasi untuk semua rute di HTTP API Anda. Anda mungkin perlu melakukan ini untuk mematuhi berbagai kerangka kerja kepatuhan. Untuk informasi selengkapnya, lihat [kontrol Amazon API Gateway](https://docs.aws.amazon.com/securityhub/latest/userguide/apigateway-controls.html) di *Panduan AWS Security Hub Pengguna*.
# Kontrol akses ke HTTP APIs dengan AWS Lambda otorisasi
Anda menggunakan otorisasi Lambda untuk menggunakan fungsi Lambda untuk mengontrol akses ke HTTP API Anda. Kemudian, ketika klien memanggil API Anda, API Gateway memanggil fungsi Lambda Anda. API Gateway menggunakan respons dari fungsi Lambda Anda untuk menentukan apakah klien dapat mengakses API Anda.
## Versi format muatan
Versi format payload authorizer menentukan format data yang dikirimkan API Gateway ke pengotorisasi Lambda, dan bagaimana API Gateway menafsirkan respons dari Lambda. Jika Anda tidak menentukan versi format payload, akan Konsol Manajemen AWS menggunakan versi terbaru secara default. Jika Anda membuat otorisasi Lambda menggunakan AWS CLI,, atau SDK CloudFormation, Anda harus menentukan. `authorizerPayloadFormatVersion` Nilai yang di-support adalah `1.0` dan `2.0`.
Jika Anda membutuhkan kompatibilitas dengan REST APIs, gunakan versi`1.0`.
Contoh berikut menunjukkan struktur setiap versi format payload.
------
#### [ 2.0 ]
```
{
"version": "2.0",
"type": "REQUEST",
"routeArn": "arn:aws:execute-api:us-east-1:123456789012:abcdef123/test/GET/request",
"identitySource": ["user1", "123"],
"routeKey": "$default",
"rawPath": "/my/path",
"rawQueryString": "parameter1=value1¶meter1=value2¶meter2=value",
"cookies": ["cookie1", "cookie2"],
"headers": {
"header1": "value1",
"header2": "value2"
},
"queryStringParameters": {
"parameter1": "value1,value2",
"parameter2": "value"
},
"requestContext": {
"accountId": "123456789012",
"apiId": "api-id",
"authentication": {
"clientCert": {
"clientCertPem": "CERT_CONTENT",
"subjectDN": "www.example.com",
"issuerDN": "Example issuer",
"serialNumber": "1",
"validity": {
"notBefore": "May 28 12:30:02 2019 GMT",
"notAfter": "Aug 5 09:36:04 2021 GMT"
}
}
},
"domainName": "id.execute-api.us-east-1.amazonaws.com",
"domainPrefix": "id",
"http": {
"method": "POST",
"path": "/my/path",
"protocol": "HTTP/1.1",
"sourceIp": "IP",
"userAgent": "agent"
},
"requestId": "id",
"routeKey": "$default",
"stage": "$default",
"time": "12/Mar/2020:19:03:58 +0000",
"timeEpoch": 1583348638390
},
"pathParameters": { "parameter1": "value1" },
"stageVariables": { "stageVariable1": "value1", "stageVariable2": "value2" }
}
```
------
#### [ 1.0 ]
```
{
"version": "1.0",
"type": "REQUEST",
"methodArn": "arn:aws:execute-api:us-east-1:123456789012:abcdef123/test/GET/request",
"identitySource": "user1,123",
"authorizationToken": "user1,123",
"resource": "/request",
"path": "/request",
"httpMethod": "GET",
"headers": {
"X-AMZ-Date": "20170718T062915Z",
"Accept": "*/*",
"HeaderAuth1": "headerValue1",
"CloudFront-Viewer-Country": "US",
"CloudFront-Forwarded-Proto": "https",
"CloudFront-Is-Tablet-Viewer": "false",
"CloudFront-Is-Mobile-Viewer": "false",
"User-Agent": "..."
},
"queryStringParameters": {
"QueryString1": "queryValue1"
},
"pathParameters": {},
"stageVariables": {
"StageVar1": "stageValue1"
},
"requestContext": {
"path": "/request",
"accountId": "123456789012",
"resourceId": "05c7jb",
"stage": "test",
"requestId": "...",
"identity": {
"apiKey": "...",
"sourceIp": "...",
"clientCert": {
"clientCertPem": "CERT_CONTENT",
"subjectDN": "www.example.com",
"issuerDN": "Example issuer",
"serialNumber": "a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1",
"validity": {
"notBefore": "May 28 12:30:02 2019 GMT",
"notAfter": "Aug 5 09:36:04 2021 GMT"
}
}
},
"resourcePath": "/request",
"httpMethod": "GET",
"apiId": "abcdef123"
}
}
```
------
## Format respons otorisasi Lambda
Versi format payload juga menentukan struktur respons yang harus Anda kembalikan dari fungsi Lambda Anda.
### Respons fungsi Lambda untuk format 1.0
Jika Anda memilih versi `1.0` format, otorisasi Lambda harus menampilkan kebijakan IAM yang mengizinkan atau menolak akses ke rute API Anda. Anda dapat menggunakan sintaks kebijakan IAM standar dalam kebijakan. Untuk contoh kebijakan IAM, lihat[Kontrol akses untuk menjalankan API](api-gateway-control-access-using-iam-policies-to-invoke-api.md). Anda dapat meneruskan properti konteks ke integrasi Lambda atau mengakses log dengan menggunakan. `$context.authorizer.property` `context`Objek adalah opsional dan `claims` merupakan placeholder yang dicadangkan dan tidak dapat digunakan sebagai objek konteks. Untuk mempelajari selengkapnya, lihat [Sesuaikan log akses HTTP API](http-api-logging-variables.md).
**Example**
****
```
{
"principalId": "abcdef",
"policyDocument": {
"Version":"2012-10-17",
"Statement": [
{
"Action": "execute-api:Invoke",
"Effect": "Allow|Deny",
"Resource": "arn:aws:execute-api:{regionId}:{accountId}:{apiId}/{stage}/{httpVerb}/[{resource}/[{child-resources}]]"
}
]
},
"context": {
"exampleKey": "exampleValue"
}
}
```
### Respons fungsi Lambda untuk format 2.0
Jika Anda memilih versi `2.0` format, Anda dapat mengembalikan nilai Boolean atau kebijakan IAM yang menggunakan sintaks kebijakan IAM standar dari fungsi Lambda Anda. Untuk mengembalikan nilai Boolean, aktifkan tanggapan sederhana untuk otorisasi. Contoh berikut menunjukkan format yang harus Anda kodekan fungsi Lambda Anda untuk kembali. `context`Objek adalah opsional. Anda dapat meneruskan properti konteks ke integrasi Lambda atau mengakses log dengan menggunakan. `$context.authorizer.property` Untuk mempelajari selengkapnya, lihat [Sesuaikan log akses HTTP API](http-api-logging-variables.md).
------
#### [ Simple response ]
```
{
"isAuthorized": true/false,
"context": {
"exampleKey": "exampleValue"
}
}
```
------
#### [ IAM policy ]
****
```
{
"principalId": "abcdef",
"policyDocument": {
"Version":"2012-10-17",
"Statement": [
{
"Action": "execute-api:Invoke",
"Effect": "Allow|Deny",
"Resource": "arn:aws:execute-api:{regionId}:{accountId}:{apiId}/{stage}/{httpVerb}/[{resource}/[{child-resources}]]"
}
]
},
"context": {
"exampleKey": "exampleValue"
}
}
```
------
## Contoh fungsi otorisasi Lambda
Contoh berikut fungsi Lambda Node.js menunjukkan format respons yang diperlukan yang perlu Anda kembalikan dari fungsi Lambda Anda untuk versi format payload. `2.0`
------
#### [ Simple response - Node.js ]
```
export const handler = async(event) => {
let response = {
"isAuthorized": false,
"context": {
"stringKey": "value",
"numberKey": 1,
"booleanKey": true,
"arrayKey": ["value1", "value2"],
"mapKey": {"value1": "value2"}
}
};
if (event.headers.authorization === "secretToken") {
console.log("allowed");
response = {
"isAuthorized": true,
"context": {
"stringKey": "value",
"numberKey": 1,
"booleanKey": true,
"arrayKey": ["value1", "value2"],
"mapKey": {"value1": "value2"}
}
};
}
return response;
};
```
------
#### [ Simple response - Python ]
```
import json
def lambda_handler(event, context):
response = {
"isAuthorized": False,
"context": {
"stringKey": "value",
"numberKey": 1,
"booleanKey": True,
"arrayKey": ["value1", "value2"],
"mapKey": {"value1": "value2"}
}
}
try:
if (event["headers"]["authorization"] == "secretToken"):
response = {
"isAuthorized": True,
"context": {
"stringKey": "value",
"numberKey": 1,
"booleanKey": True,
"arrayKey": ["value1", "value2"],
"mapKey": {"value1": "value2"}
}
}
print('allowed')
return response
else:
print('denied')
return response
except BaseException:
print('denied')
return response
```
------
#### [ IAM policy - Node.js ]
```
export const handler = async(event) => {
if (event.headers.authorization == "secretToken") {
console.log("allowed");
return {
"principalId": "abcdef", // The principal user identification associated with the token sent by the client.
"policyDocument": {
"Version": "2012-10-17",
"Statement": [{
"Action": "execute-api:Invoke",
"Effect": "Allow",
"Resource": event.routeArn
}]
},
"context": {
"stringKey": "value",
"numberKey": 1,
"booleanKey": true,
"arrayKey": ["value1", "value2"],
"mapKey": { "value1": "value2" }
}
};
}
else {
console.log("denied");
return {
"principalId": "abcdef", // The principal user identification associated with the token sent by the client.
"policyDocument": {
"Version": "2012-10-17",
"Statement": [{
"Action": "execute-api:Invoke",
"Effect": "Deny",
"Resource": event.routeArn
}]
},
"context": {
"stringKey": "value",
"numberKey": 1,
"booleanKey": true,
"arrayKey": ["value1", "value2"],
"mapKey": { "value1": "value2" }
}
};
}
};
```
------
#### [ IAM policy - Python ]
```
import json
def lambda_handler(event, context):
response = {
# The principal user identification associated with the token sent by
# the client.
"principalId": "abcdef",
"policyDocument": {
"Version": "2012-10-17",
"Statement": [{
"Action": "execute-api:Invoke",
"Effect": "Deny",
"Resource": event["routeArn"]
}]
},
"context": {
"stringKey": "value",
"numberKey": 1,
"booleanKey": True,
"arrayKey": ["value1", "value2"],
"mapKey": {"value1": "value2"}
}
}
try:
if (event["headers"]["authorization"] == "secretToken"):
response = {
# The principal user identification associated with the token
# sent by the client.
"principalId": "abcdef",
"policyDocument": {
"Version": "2012-10-17",
"Statement": [{
"Action": "execute-api:Invoke",
"Effect": "Allow",
"Resource": event["routeArn"]
}]
},
"context": {
"stringKey": "value",
"numberKey": 1,
"booleanKey": True,
"arrayKey": ["value1", "value2"],
"mapKey": {"value1": "value2"}
}
}
print('allowed')
return response
else:
print('denied')
return response
except BaseException:
print('denied')
return response
```
------
## Sumber identitas
Anda dapat secara opsional menentukan sumber identitas untuk otorisasi Lambda. Sumber identitas menentukan lokasi data yang diperlukan untuk mengotorisasi permintaan. Misalnya, Anda dapat menentukan nilai string header atau kueri sebagai sumber identitas. Jika Anda menentukan sumber identitas, klien harus memasukkannya dalam permintaan. Jika permintaan klien tidak menyertakan sumber identitas, API Gateway tidak memanggil otorisasi Lambda Anda, dan klien menerima kesalahan. `401`
Tabel berikut menjelaskan sumber identitas yang didukung untuk otorisasi Lambda.
| **Jenis** | **Contoh** | **Catatan** |
| --- | --- | --- |
| Nilai header | \$1 request.header. name | Nama header tidak peka huruf besar/kecil. |
| Nilai string kueri | \$1request.querystring. name | Nama string kueri peka huruf besar/kecil. |
| Variabel konteks | \$1 konteks. variableName | Nilai [variabel konteks](http-api-logging-variables.md) yang didukung. |
| Variabel tahap | \$1 StageVariables. variableName | Nilai [variabel tahap](http-api-stages.stage-variables.md). |
Anda juga dapat langsung kembali ` {"errorMessage" : "Unauthorized"}` dari fungsi Lambda Anda untuk mengembalikan `401` kesalahan ke klien Anda. Jika Anda langsung mengembalikan `401` kesalahan dari fungsi Lambda ke klien Anda, jangan tentukan sumber identitas apa pun saat Anda membuat otorisasi Lambda.
## Tanggapan otorisasi cache
Anda dapat mengaktifkan caching untuk otorisasi Lambda dengan menentukan file. [authorizerResultTtlInSeconds](https://docs.aws.amazon.com/apigatewayv2/latest/api-reference/apis-apiid-authorizers.html#apis-apiid-authorizers-prop-createauthorizerinput-authorizerresultttlinseconds) Saat caching diaktifkan untuk otorisasi, API Gateway menggunakan sumber identitas otorisasi sebagai kunci cache. Jika klien menentukan parameter yang sama dalam sumber identitas dalam TTL yang dikonfigurasi, API Gateway menggunakan hasil otorisasi yang di-cache, daripada menjalankan fungsi Lambda Anda.
Untuk mengaktifkan caching, otorisasi Anda harus memiliki setidaknya satu sumber identitas.
Jika Anda mengaktifkan respons sederhana untuk otorisasi, respons otorisasi sepenuhnya mengizinkan atau menolak semua permintaan API yang cocok dengan nilai sumber identitas cache. Untuk izin yang lebih terperinci, nonaktifkan tanggapan sederhana dan kembalikan kebijakan IAM. Bergantung pada otorisasi Anda, kebijakan IAM Anda mungkin perlu mengontrol akses ke beberapa.
Secara default, API Gateway menggunakan respons otorisasi yang di-cache untuk semua rute API yang menggunakan otorisasi. Untuk menyimpan respons per rute, tambahkan `$context.routeKey` ke sumber identitas otorisasi Anda.
## Buat Authorizer Lambda
Saat membuat otorisasi Lambda, Anda menentukan fungsi Lambda untuk API Gateway yang akan digunakan. Anda harus memberikan izin API Gateway untuk menjalankan fungsi Lambda dengan menggunakan kebijakan sumber daya fungsi atau peran IAM. Perintah [create-authorizer berikut membuat authorizer](https://docs.aws.amazon.com/cli/latest/reference/apigatewayv2/create-authorizer.html) Lambda:
```
aws apigatewayv2 create-authorizer \
--api-id abcdef123 \
--authorizer-type REQUEST \
--identity-source '$request.header.Authorization' \
--name lambda-authorizer \
--authorizer-uri 'arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:123456789012:function:my-function/invocations' \
--authorizer-payload-format-version '2.0' \
--enable-simple-responses
```
Perintah [izin tambahan](https://docs.aws.amazon.com/cli/latest/reference/lambda/add-permission.html) berikut memperbarui kebijakan sumber daya fungsi Lambda untuk memberikan izin API Gateway untuk menjalankan fungsi tersebut. Jika API Gateway tidak memiliki izin untuk menjalankan fungsi Anda, klien akan menerima file. `500 Internal Server Error`
```
aws lambda add-permission \
--function-name my-authorizer-function \
--statement-id apigateway-invoke-permissions-abc123 \
--action lambda:InvokeFunction \
--principal apigateway.amazonaws.com \
--source-arn "arn:aws:execute-api:us-west-2:123456789012:api-id/authorizers/authorizer-id"
```
Setelah Anda membuat otorisasi dan memberikan izin API Gateway untuk memanggilnya, perbarui rute Anda untuk menggunakan otorisasi. Perintah [update-route](https://docs.aws.amazon.com/cli/latest/reference/apigatewayv2/update-route.html) berikut menambahkan Lambda authorizer ke rute. Jika otorisasi Lambda Anda menggunakan caching kebijakan, pastikan Anda memperbarui kebijakan untuk mengontrol akses untuk rute tambahan.
```
aws apigatewayv2 update-route \
--api-id abcdef123 \
--route-id abc123 \
--authorization-type CUSTOM \
--authorizer-id def123
```
## Memecahkan masalah otorisasi Lambda
Jika API Gateway tidak dapat memanggil otorisasi Lambda Anda, atau otorisasi Lambda Anda mengembalikan respons dalam format yang tidak valid, klien akan menerima file. `500 Internal Server Error`
Untuk memecahkan masalah kesalahan, [aktifkan pencatatan akses untuk tahap](http-api-logging.md) API Anda. Sertakan variabel `$context.authorizer.error` logging dalam format log Anda.
Jika log menunjukkan bahwa API Gateway tidak memiliki izin untuk menjalankan fungsi Anda, perbarui kebijakan sumber daya fungsi Anda atau berikan peran IAM untuk memberikan izin API Gateway untuk memanggil otorisasi Anda.
[Jika log menunjukkan bahwa fungsi Lambda Anda mengembalikan respons yang tidak valid, verifikasi bahwa fungsi Lambda Anda mengembalikan respons dalam format yang diperlukan.](#http-api-lambda-authorizer.payload-format-response)
# Kontrol akses ke HTTP APIs dengan otorisasi JWT di API Gateway
Anda dapat menggunakan JSON Web Tokens (JWTs) sebagai bagian dari [OpenID Connect (](https://openid.net/specs/openid-connect-core-1_0.html)OIDC [OAuth )](https://oauth.net/2/) dan 2.0 framework untuk membatasi akses klien ke Anda. APIs
Jika Anda mengonfigurasi otorisasi JWT untuk rute API Anda, API Gateway memvalidasi yang dikirimkan klien dengan JWTs permintaan API. API Gateway memungkinkan atau menolak permintaan berdasarkan validasi token, dan secara opsional, cakupan dalam token. Jika Anda mengonfigurasi cakupan untuk rute, token harus menyertakan setidaknya satu cakupan rute.
Anda dapat mengonfigurasi otorisasi yang berbeda untuk setiap rute API, atau menggunakan otorisasi yang sama untuk beberapa rute.
**catatan**
Tidak ada mekanisme standar untuk membedakan token akses JWT dari jenis lain JWTs, seperti token ID OpenID Connect. Kecuali Anda memerlukan token ID untuk otorisasi API, kami sarankan Anda mengonfigurasi rute Anda agar memerlukan cakupan otorisasi. Anda juga dapat mengonfigurasi otorisasi JWT Anda untuk meminta penerbit atau audiens yang hanya digunakan penyedia identitas Anda saat mengeluarkan token akses JWT.
## Mengotorisasi permintaan API dengan otorisasi JWT
API Gateway menggunakan alur kerja umum berikut untuk mengotorisasi permintaan ke rute yang dikonfigurasi untuk menggunakan otorisasi JWT.
1. [https://docs.aws.amazon.com/apigatewayv2/latest/api-reference/apis-apiid-authorizers-authorizerid.html#apis-apiid-authorizers-authorizerid-prop-authorizer-identitysource](https://docs.aws.amazon.com/apigatewayv2/latest/api-reference/apis-apiid-authorizers-authorizerid.html#apis-apiid-authorizers-authorizerid-prop-authorizer-identitysource)Periksa token. `identitySource`Dapat hanya menyertakan token, atau token yang diawali dengan`Bearer`.
1. Mendekode token.
1. Periksa algoritma dan tanda tangan token dengan menggunakan kunci publik yang diambil dari penerbit. `jwks_uri` Saat ini, hanya algoritma berbasis RSA yang didukung. API Gateway dapat menyimpan kunci publik selama dua jam. Sebagai praktik terbaik, saat Anda memutar tombol, izinkan masa tenggang di mana kunci lama dan baru valid.
1. Validasi klaim. API Gateway mengevaluasi klaim token berikut:
+ [https://datatracker.ietf.org/doc/html/rfc7517#section-4.5](https://datatracker.ietf.org/doc/html/rfc7517#section-4.5)— Token harus memiliki klaim header yang cocok dengan kunci `jwks_uri` yang menandatangani token.
+ [https://datatracker.ietf.org/doc/html/rfc7519#section-4.1.1](https://datatracker.ietf.org/doc/html/rfc7519#section-4.1.1)— Harus cocok dengan [https://docs.aws.amazon.com/apigatewayv2/latest/api-reference/apis-apiid-authorizers-authorizerid.html#apis-apiid-authorizers-authorizerid-model-jwtconfiguration](https://docs.aws.amazon.com/apigatewayv2/latest/api-reference/apis-apiid-authorizers-authorizerid.html#apis-apiid-authorizers-authorizerid-model-jwtconfiguration)yang dikonfigurasi untuk otorisasi.
+ [https://datatracker.ietf.org/doc/html/rfc7519#section-4.1.3](https://datatracker.ietf.org/doc/html/rfc7519#section-4.1.3)atau `client_id` — Harus cocok dengan salah satu [https://docs.aws.amazon.com/apigatewayv2/latest/api-reference/apis-apiid-authorizers-authorizerid.html#apis-apiid-authorizers-authorizerid-model-jwtconfiguration](https://docs.aws.amazon.com/apigatewayv2/latest/api-reference/apis-apiid-authorizers-authorizerid.html#apis-apiid-authorizers-authorizerid-model-jwtconfiguration)entri yang dikonfigurasi untuk otorisasi. API Gateway `client_id` hanya memvalidasi jika tidak `aud` ada. Saat keduanya `aud` dan `client_id` ada, API Gateway mengevaluasi. `aud`
+ [https://datatracker.ietf.org/doc/html/rfc7519#section-4.1.4](https://datatracker.ietf.org/doc/html/rfc7519#section-4.1.4)— Harus setelah waktu saat ini di UTC.
+ [https://datatracker.ietf.org/doc/html/rfc7519#section-4.1.5](https://datatracker.ietf.org/doc/html/rfc7519#section-4.1.5)— Harus sebelum waktu saat ini di UTC.
+ [https://datatracker.ietf.org/doc/html/rfc7519#section-4.1.6](https://datatracker.ietf.org/doc/html/rfc7519#section-4.1.6)— Harus sebelum waktu saat ini di UTC.
+ [https://datatracker.ietf.org/doc/html/rfc6749#section-3.3](https://datatracker.ietf.org/doc/html/rfc6749#section-3.3)atau `scp` — Token harus menyertakan setidaknya satu cakupan dalam rute. [https://docs.aws.amazon.com/apigatewayv2/latest/api-reference/apis-apiid-routes-routeid.html#apis-apiid-routes-routeid-prop-updaterouteinput-authorizationscopes](https://docs.aws.amazon.com/apigatewayv2/latest/api-reference/apis-apiid-routes-routeid.html#apis-apiid-routes-routeid-prop-updaterouteinput-authorizationscopes)
Jika salah satu langkah ini gagal, API Gateway menolak permintaan API.
Setelah memvalidasi JWT, API Gateway meneruskan klaim dalam token ke integrasi rute API. Sumber daya backend, seperti fungsi Lambda, dapat mengakses klaim JWT. Misalnya, jika JWT menyertakan klaim identitas`emailID`, itu tersedia untuk integrasi Lambda di. `$event.requestContext.authorizer.jwt.claims.emailID` Untuk informasi selengkapnya tentang payload yang dikirimkan API Gateway ke integrasi Lambda, lihat. [Buat integrasi AWS Lambda proxy untuk HTTP APIs di API Gateway](http-api-develop-integrations-lambda.md)
## Buat otorisasi JWT
Sebelum Anda membuat otorisasi JWT, Anda harus mendaftarkan aplikasi klien dengan penyedia identitas. Anda juga harus membuat API HTTP. Untuk contoh pembuatan API HTTP, lihat[Buat API HTTP](http-api-develop.md#http-api-examples).
### Buat otorisasi JWT menggunakan konsol
Langkah-langkah berikut menunjukkan cara membuat otorisasi JWT menggunakan konsol.
**Untuk membuat otorisasi JWT menggunakan konsol**
1. Masuk ke konsol API Gateway di [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. Pilih API HTTP.
1. Di panel navigasi utama, pilih **Otorisasi**.
1. Pilih tab **Kelola otorisasi**.
1. Pilih **Buat**.
1. Untuk **jenis Authorizer**, pilih **JWT**.
1. Konfigurasikan otorisasi JWT Anda, dan tentukan **sumber Identitas** yang menentukan sumber token.
1. Pilih **Buat**.
#### Buat otorisasi JWT menggunakan AWS CLI
Perintah [create-authorizer berikut membuat authorizer](https://docs.aws.amazon.com/cli/latest/reference/apigatewayv2/create-authorizer.html) JWT. Untuk`jwt-configuration`, tentukan `Audience` dan `Issuer` untuk penyedia identitas Anda. Jika Anda menggunakan Amazon Cognito sebagai penyedia identitas, itu adalah. `IssuerUrl` `https://cognito-idp.us-east-2.amazonaws.com/userPoolID`
```
aws apigatewayv2 create-authorizer \
--name authorizer-name \
--api-id api-id \
--authorizer-type JWT \
--identity-source '$request.header.Authorization' \
--jwt-configuration Audience=audience,Issuer=IssuerUrl
```
##### Buat otorisasi JWT menggunakan AWS CloudFormation
CloudFormation Template berikut membuat API HTTP dengan otorisasi JWT yang menggunakan Amazon Cognito sebagai penyedia identitas.
Output dari CloudFormation template adalah URL untuk UI yang dihosting Amazon Cognito tempat klien dapat mendaftar dan masuk untuk menerima JWT. Setelah klien masuk, klien dialihkan ke HTTP API Anda dengan token akses di URL. Untuk menjalankan API dengan token akses, ubah URL ke a `?` untuk menggunakan token sebagai parameter string kueri. `#`
##### Contoh CloudFormation template
```
AWSTemplateFormatVersion: '2010-09-09'
Description: |
Example HTTP API with a JWT authorizer. This template includes an Amazon Cognito user pool as the issuer for the JWT authorizer
and an Amazon Cognito app client as the audience for the authorizer. The outputs include a URL for an Amazon Cognito hosted UI where clients can
sign up and sign in to receive a JWT. After a client signs in, the client is redirected to your HTTP API with an access token
in the URL. To invoke the API with the access token, change the '#' in the URL to a '?' to use the token as a query string parameter.
Resources:
MyAPI:
Type: AWS::ApiGatewayV2::Api
Properties:
Description: Example HTTP API
Name: api-with-auth
ProtocolType: HTTP
Target: !GetAtt MyLambdaFunction.Arn
DefaultRouteOverrides:
Type: AWS::ApiGatewayV2::ApiGatewayManagedOverrides
Properties:
ApiId: !Ref MyAPI
Route:
AuthorizationType: JWT
AuthorizerId: !Ref JWTAuthorizer
JWTAuthorizer:
Type: AWS::ApiGatewayV2::Authorizer
Properties:
ApiId: !Ref MyAPI
AuthorizerType: JWT
IdentitySource:
- '$request.querystring.access_token'
JwtConfiguration:
Audience:
- !Ref AppClient
Issuer: !Sub https://cognito-idp.${AWS::Region}.amazonaws.com/${UserPool}
Name: test-jwt-authorizer
MyLambdaFunction:
Type: AWS::Lambda::Function
Properties:
Runtime: nodejs18.x
Role: !GetAtt FunctionExecutionRole.Arn
Handler: index.handler
Code:
ZipFile: |
exports.handler = async (event) => {
const response = {
statusCode: 200,
body: JSON.stringify('Hello from the ' + event.routeKey + ' route!'),
};
return response;
};
APIInvokeLambdaPermission:
Type: AWS::Lambda::Permission
Properties:
FunctionName: !Ref MyLambdaFunction
Action: lambda:InvokeFunction
Principal: apigateway.amazonaws.com
SourceArn: !Sub arn:${AWS::Partition}:execute-api:${AWS::Region}:${AWS::AccountId}:${MyAPI}/$default/$default
FunctionExecutionRole:
Type: AWS::IAM::Role
Properties:
AssumeRolePolicyDocument:
Version: '2012-10-17 '
Statement:
- Effect: Allow
Principal:
Service:
- lambda.amazonaws.com
Action:
- 'sts:AssumeRole'
ManagedPolicyArns:
- arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
UserPool:
Type: AWS::Cognito::UserPool
Properties:
UserPoolName: http-api-user-pool
AutoVerifiedAttributes:
- email
Schema:
- Name: name
AttributeDataType: String
Mutable: true
Required: true
- Name: email
AttributeDataType: String
Mutable: false
Required: true
AppClient:
Type: AWS::Cognito::UserPoolClient
Properties:
AllowedOAuthFlows:
- implicit
AllowedOAuthScopes:
- aws.cognito.signin.user.admin
- email
- openid
- profile
AllowedOAuthFlowsUserPoolClient: true
ClientName: api-app-client
CallbackURLs:
- !Sub https://${MyAPI}.execute-api.${AWS::Region}.amazonaws.com
ExplicitAuthFlows:
- ALLOW_USER_PASSWORD_AUTH
- ALLOW_REFRESH_TOKEN_AUTH
UserPoolId: !Ref UserPool
SupportedIdentityProviders:
- COGNITO
HostedUI:
Type: AWS::Cognito::UserPoolDomain
Properties:
Domain: !Join
- '-'
- - !Ref MyAPI
- !Ref AppClient
UserPoolId: !Ref UserPool
Outputs:
SignupURL:
Value: !Sub https://${HostedUI}.auth.${AWS::Region}.amazoncognito.com/login?client_id=${AppClient}&response_type=token&scope=email+profile&redirect_uri=https://${MyAPI}.execute-api.${AWS::Region}.amazonaws.com
```
## Perbarui rute untuk menggunakan otorisasi JWT
Anda dapat menggunakan konsol, SDK AWS CLI, atau AWS SDK untuk memperbarui rute untuk menggunakan otorisasi JWT.
### Perbarui rute untuk menggunakan otorisasi JWT dengan menggunakan konsol
Langkah-langkah berikut menunjukkan cara memperbarui rute untuk menggunakan otorisasi JWT menggunakan konsol.
**Untuk membuat otorisasi JWT menggunakan konsol**
1. Masuk ke konsol API Gateway di [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. Pilih API HTTP.
1. Di panel navigasi utama, pilih **Otorisasi**.
1. **Pilih metode, lalu pilih otorisasi Anda dari menu tarik-turun, dan pilih Lampirkan otorisasi.**
#### Perbarui rute untuk menggunakan otorisasi JWT dengan menggunakan AWS CLI
Perintah [update-route](https://docs.aws.amazon.com/cli/latest/reference/apigatewayv2/update-route.html) berikut memperbarui rute untuk menggunakan otorisasi JWT:
```
aws apigatewayv2 update-route \
--api-id api-id \
--route-id route-id \
--authorization-type JWT \
--authorizer-id authorizer-id \
--authorization-scopes user.email
```
# Kontrol akses ke HTTP APIs dengan otorisasi IAM di API Gateway
Anda dapat mengaktifkan otorisasi IAM untuk rute API HTTP. Ketika otorisasi IAM diaktifkan, klien harus menggunakan [Signature Version 4 (SigV4)](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_sigv.html) untuk menandatangani permintaan mereka dengan kredensi. AWS API Gateway memanggil rute API Anda hanya jika klien memiliki `execute-api` izin untuk rute tersebut.
[Otorisasi IAM untuk HTTP APIs mirip dengan yang untuk REST. APIs](api-gateway-control-access-using-iam-policies-to-invoke-api.md)
**catatan**
Kebijakan sumber daya saat ini tidak didukung untuk HTTP APIs.
Untuk contoh kebijakan IAM yang memberikan izin kepada klien untuk memanggil APIs, lihat. [Kontrol akses untuk menjalankan API](api-gateway-control-access-using-iam-policies-to-invoke-api.md)
## Aktifkan otorisasi IAM untuk rute
Perintah [update-route](https://docs.aws.amazon.com/cli/latest/reference/apigatewayv2/update-route.html) berikut memungkinkan otorisasi IAM untuk rute API HTTP:
```
aws apigatewayv2 update-route \
--api-id abc123 \
--route-id abcdef \
--authorization-type AWS_IAM
```