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

# Kontrol akses API dengan AWS SAM template Anda
<a name="serverless-controlling-access-to-apis"></a>

Mengontrol akses ke API Gateway APIs membantu memastikan aplikasi tanpa server Anda aman dan hanya dapat diakses melalui otorisasi yang Anda aktifkan. Anda dapat mengaktifkan otorisasi di AWS SAM template Anda untuk mengontrol siapa yang dapat mengakses API Gateway APIs Anda.

AWS SAM mendukung beberapa mekanisme untuk mengontrol akses ke API Gateway Anda APIs. Kumpulan mekanisme yang didukung berbeda antara tipe sumber daya `AWS::Serverless::HttpApi` dan `AWS::Serverless::Api`.

Tabel berikut merangkum mekanisme yang didukung oleh setiap tipe sumber daya.


| Mekanisme untuk mengendalikan akses | AWS::Serverless::HttpApi | AWS::Serverless::Api | 
| --- | --- | --- | 
| Otorisator Lambda | ✓ | ✓ | 
| Izin IAM |  | ✓ | 
| Kumpulan pengguna Amazon Cognito | ✓ \$1 | ✓ | 
| Kunci API |  | ✓ | 
| Kebijakan sumber daya |  | ✓ | 
| OAuth 2.0/JWT otorisasi | ✓ |  | 

\$1 Anda dapat menggunakan Amazon Cognito sebagai penerbit JSON Web Token (JWT) dengan tipe sumber daya `AWS::Serverless::HttpApi`.
+ **Otorisasi Lambda** – Otorisasi Lambda (sebelumnya dikenal sebagai *custom authorizer*) adalah fungsi Lambda yang Anda berikan untuk mengendalikan akses ke API Anda. Saat API Anda dipanggil, fungsi Lambda ini dipanggil dengan konteks permintaan atau token otorisasi yang disediakan aplikasi klien. Fungsi Lambda merespons apakah pemanggil diotorisasi untuk melakukan operasi yang diminta.

  Tipe sumber daya `AWS::Serverless::HttpApi` dan `AWS::Serverless::Api` mendukung otorisasi Lambda.

  Untuk informasi selengkapnya tentang otorisasi Lambda`AWS::Serverless::HttpApi`, lihat [Bekerja dengan AWS Lambda otorisasi untuk HTTP](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-lambda-authorizer.html) di Panduan Pengembang APIs *API* Gateway. Untuk informasi selengkapnya tentang otorisasi Lambda dengan `AWS::Serverless::Api`, lihat [Gunakan otorisasi Lambda API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-use-lambda-authorizer.html) di *Panduan Developer API Gateway*.

  Untuk contoh otorisasi Lambda untuk kedua tipe sumber daya, lihat [Contoh otorisasi Lambda untuk AWS SAM](serverless-controlling-access-to-apis-lambda-authorizer.md).

  
+ **Izin IAM** – Anda dapat mengendalikan siapa saja yang dapat menggunakan API Anda menggunakan [Izin (IAM)AWS Identity and Access Management](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_controlling.html). Pengguna yang memanggil API Anda harus diautentikasi dengan kredensial IAM. Panggilan ke API Anda berhasil hanya jika ada kebijakan IAM yang dilampirkan ke pengguna IAM yang mewakili pemanggil API, grup IAM yang berisi pengguna, atau IAM role yang diasumsikan pengguna.

  Hanya tipe sumber daya `AWS::Serverless::Api` yang mendukung izin IAM.

  Untuk informasi selengkapnya, lihat [Mengendalikan akses ke API dengan izin IAM](https://docs.aws.amazon.com/apigateway/latest/developerguide/permissions.html) di *Panduan Developer API Gateway*. Sebagai contoh, lihat [Contoh izin IAM untuk AWS SAM](serverless-controlling-access-to-apis-permissions.md).
+ **Kolam pengguna Amazon Cognito** – Kolam pengguna Amazon Cognito adalah direktori pengguna di Amazon Cognito. Klien API Anda harus terlebih dahulu membuat pengguna masuk ke kolam pengguna dan mendapatkan identitas atau token akses untuk pengguna tersebut. Kemudian klien memanggil API Anda dengan salah satu token yang dikembalikan. Panggilan API hanya berhasil jika token yang diperlukan valid.

  Tipe sumber daya `AWS::Serverless::Api` mendukung kolam pengguna Amazon Cognito. Tipe sumber daya `AWS::Serverless::HttpApi` mendukung penggunaan Amazon Cognito sebagai penerbit JWT.

  Untuk informasi selengkapnya, lihat [Mengendalikan akses ke REST API menggunakan kolam pengguna Amazon Cognito sebagai pemberi otorisasi](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-integrate-with-cognito.html) di *Panduan Developer API Gateway*. Sebagai contoh, lihat [Contoh kumpulan pengguna Amazon Cognito untuk AWS SAM](serverless-controlling-access-to-apis-cognito-user-pool.md).
+ **Kunci API** – Kunci API adalah nilai string alfanumerik yang Anda distribusi ke pelanggan developer aplikasi untuk memberikan akses ke API Anda.

  Hanya tipe sumber daya `AWS::Serverless::Api` yang mendukung kunci API.

  Untuk informasi selengkapnya tentang kunci API, lihat [Membuat dan menggunakan rencana penggunaan dengan kunci API](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-api-usage-plans.html) di *Panduan Developer API Gateway*. Untuk contoh kunci API, lihat [Contoh kunci API untuk AWS SAM](serverless-controlling-access-to-apis-keys.md).
+ **Kebijakan sumber daya** – Kebijakan sumber daya adalah dokumen kebijakan JSON yang dapat Anda lampirkan ke API dari API Gateway. Gunakan kebijakan sumber daya untuk mengendalikan apakah principal tertentu (biasanya pengguna atau peran IAM) dapat memanggil API.

  Hanya tipe `AWS::Serverless::Api` sumber daya yang mendukung kebijakan sumber daya sebagai mekanisme untuk mengontrol akses ke API Gateway APIs.

  Untuk informasi selengkapnya tentang kebijakan sumber daya, lihat [Mengendalikan akses ke API dengan kebijakan sumber daya API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-resource-policies.html) di *Panduan Developer API Gateway*. Untuk contoh kebijakan sumber daya, lihat [Contoh kebijakan sumber daya untuk AWS SAM](serverless-controlling-access-to-apis-resource-policies.md).
+ **OAuth 2.0/JWT authorizers** [- Anda dapat menggunakan JWTs sebagai bagian dari OpenID [Connect (OIDC)](https://openid.net/specs/openid-connect-core-1_0.html) dan 2.0 framework untuk mengontrol akses ke Anda. OAuth ](https://oauth.net/2/) APIs API Gateway memvalidasi JWTs yang dikirimkan klien dengan permintaan API, dan mengizinkan atau menolak permintaan berdasarkan validasi token dan, secara opsional, cakupan dalam token.

  Hanya jenis `AWS::Serverless::HttpApi` sumber daya yang mendukung otorisasi OAuth 2.0/JWT.

  Untuk informasi selengkapnya, lihat [Mengontrol akses ke HTTP APIs dengan otorisasi JWT di Panduan Pengembang](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-jwt-authorizer.html) *API Gateway*. Sebagai contoh, lihat [OAuth 2.0/JWT authorizer contoh untuk AWS SAM](serverless-controlling-access-to-apis-oauth2-authorizer.md).

## Memilih mekanisme untuk mengendalikan akses
<a name="serverless-controlling-access-to-apis-choices"></a>

Mekanisme yang Anda pilih untuk digunakan untuk mengontrol akses ke API Gateway Anda APIs bergantung pada beberapa faktor. Misalnya, jika Anda memiliki proyek greenfield tanpa menyiapkan otorisasi atau kendali akses, maka kolam pengguna Amazon Cognito mungkin menjadi pilihan terbaik Anda. Ini karena saat Anda menyiapkan kolam pengguna, Anda juga secara otomatis menyiapkan autentikasi dan kendali akses.

Namun, jika aplikasi Anda sudah menyiapkan autentikasi, maka menggunakan otorisasi Lambda mungkin merupakan pilihan terbaik Anda. Ini karena Anda dapat memanggil layanan autentikasi yang ada dan mengembalikan dokumen kebijakan berdasarkan respons. Selain itu, jika aplikasi Anda memerlukan autentikasi khusus atau logika kendali akses yang tidak didukung oleh kolam pengguna, maka otorisasi Lambda mungkin merupakan pilihan terbaik Anda.

Ketika Anda telah memilih mekanisme mana yang akan digunakan, lihat bagian yang sesuai [Contoh](#serverless-controlling-access-to-apis-examples) untuk cara menggunakan AWS SAM untuk mengonfigurasi aplikasi Anda untuk menggunakan mekanisme itu.

## Menyesuaikan respons kesalahan
<a name="serverless-controlling-access-to-apis-responses"></a>

Anda dapat menggunakan AWS SAM untuk menyesuaikan konten dari beberapa respons kesalahan API Gateway. Hanya tipe sumber daya `AWS::Serverless::Api` yang mendukung respons API Gateway yang disesuaikan.

Untuk informasi selengkapnya tentang respons API Gateway, lihat [Respon gateway di API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-gatewayResponse-definition.html) di *Panduan Developer API Gateway*. Untuk contoh respons yang disesuaikan, lihat [Contoh respons yang disesuaikan untuk AWS SAM](serverless-controlling-access-to-apis-customize-response.md).

## Contoh
<a name="serverless-controlling-access-to-apis-examples"></a>
+ [Contoh otorisasi Lambda untuk AWS SAM](serverless-controlling-access-to-apis-lambda-authorizer.md)
+ [Contoh izin IAM untuk AWS SAM](serverless-controlling-access-to-apis-permissions.md)
+ [Contoh kumpulan pengguna Amazon Cognito untuk AWS SAM](serverless-controlling-access-to-apis-cognito-user-pool.md)
+ [Contoh kunci API untuk AWS SAM](serverless-controlling-access-to-apis-keys.md)
+ [Contoh kebijakan sumber daya untuk AWS SAM](serverless-controlling-access-to-apis-resource-policies.md)
+ [OAuth 2.0/JWT authorizer contoh untuk AWS SAM](serverless-controlling-access-to-apis-oauth2-authorizer.md)
+ [Contoh respons yang disesuaikan untuk AWS SAM](serverless-controlling-access-to-apis-customize-response.md)

# Contoh otorisasi Lambda untuk AWS SAM
<a name="serverless-controlling-access-to-apis-lambda-authorizer"></a>

Tipe sumber daya `AWS::Serverless::Api` yang mendukung dua tipe otorisasi Lambda: otorisasi `TOKEN` dan otorisasi `REQUEST`. Tipe sumber daya `AWS::Serverless::HttpApi` hanya mendukung otorisasi `REQUEST`. Berikut ini adalah contoh dari setiap tipe.

## Contoh `TOKEN` otorisasi Lambda () AWS::Serverless::Api
<a name="serverless-controlling-access-to-apis-lambda-token-authorizer"></a>

Anda dapat mengontrol akses ke Anda APIs dengan mendefinisikan otorisasi `TOKEN` Lambda dalam template Anda. AWS SAM Untuk melakukannya, Anda menggunakan tipe data [ApiAuth](sam-property-api-apiauth.md).

Berikut ini adalah contoh bagian AWS SAM template untuk Authorizer Lambda`TOKEN`:

**catatan**  
Dalam contoh berikut, SAM dihasilkan `FunctionRole` secara implisit.

```
Resources:
  MyApi:
    Type: AWS::Serverless::Api
    Properties:
      StageName: Prod
      Auth:
        DefaultAuthorizer: MyLambdaTokenAuthorizer
        Authorizers:
          MyLambdaTokenAuthorizer:
            FunctionArn: !GetAtt MyAuthFunction.Arn

  MyFunction:
    Type: AWS::Serverless::Function
    Properties:
      CodeUri: ./src
      Handler: index.handler
      Runtime: nodejs12.x
      Events:
        GetRoot:
          Type: Api
          Properties:
            RestApiId: !Ref MyApi
            Path: /
            Method: get

  MyAuthFunction:
    Type: AWS::Serverless::Function
    Properties:
      CodeUri: ./src
      Handler: authorizer.handler
      Runtime: nodejs12.x
```

Untuk informasi selengkapnya tentang otorisasi Lambda, lihat [Gunakan otorisasi Lambda API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-use-lambda-authorizer.html) di *Panduan Developer API Gateway*.

## Contoh `REQUEST` otorisasi Lambda () AWS::Serverless::Api
<a name="serverless-controlling-access-to-apis-lambda-request-authorizer"></a>

Anda dapat mengontrol akses ke Anda APIs dengan mendefinisikan otorisasi `REQUEST` Lambda dalam template Anda. AWS SAM Untuk melakukannya, Anda menggunakan tipe data [ApiAuth](sam-property-api-apiauth.md).

Berikut ini adalah contoh bagian AWS SAM template untuk Authorizer Lambda`REQUEST`:

```
Resources:
  MyApi:
    Type: AWS::Serverless::Api
    Properties:
      StageName: Prod
      Auth:
        DefaultAuthorizer: MyLambdaRequestAuthorizer
        Authorizers:
          MyLambdaRequestAuthorizer:
            FunctionPayloadType: REQUEST
            FunctionArn: !GetAtt MyAuthFunction.Arn
            Identity:
              QueryStrings:
                - auth

  MyFunction:
    Type: AWS::Serverless::Function
    Properties:
      CodeUri: ./src
      Handler: index.handler
      Runtime: nodejs12.x
      Events:
        GetRoot:
          Type: Api
          Properties:
            RestApiId: !Ref MyApi
            Path: /
            Method: get

  MyAuthFunction:
    Type: AWS::Serverless::Function
    Properties:
      CodeUri: ./src
      Handler: authorizer.handler
      Runtime: nodejs12.x
```

Untuk informasi selengkapnya tentang otorisasi Lambda, lihat [Gunakan otorisasi Lambda API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-use-lambda-authorizer.html) di *Panduan Developer API Gateway*.

## Contoh otorisasi Lambda () AWS::Serverless::HttpApi
<a name="serverless-controlling-access-to-apis-lambda-authorizer-httpapi"></a>

Anda dapat mengontrol akses ke HTTP Anda APIs dengan mendefinisikan Lambda authorizer dalam template Anda. AWS SAM Untuk melakukannya, Anda menggunakan tipe data [HttpApiAuth](sam-property-httpapi-httpapiauth.md).

Berikut ini adalah contoh bagian AWS SAM template untuk Authorizer Lambda:

```
Resources:
  MyApi:
    Type: AWS::Serverless::HttpApi
    Properties:
      StageName: Prod
      Auth:
        DefaultAuthorizer: MyLambdaRequestAuthorizer
        Authorizers:
          MyLambdaRequestAuthorizer:
            FunctionArn: !GetAtt MyAuthFunction.Arn
            FunctionInvokeRole: !GetAtt MyAuthFunctionRole.Arn
            Identity:
              Headers:
                - Authorization
            AuthorizerPayloadFormatVersion: 2.0
            EnableSimpleResponses: true

  MyFunction:
    Type: AWS::Serverless::Function
    Properties:
      CodeUri: ./src
      Handler: index.handler
      Runtime: nodejs12.x
      Events:
        GetRoot:
          Type: HttpApi
          Properties:
            ApiId: !Ref MyApi
            Path: /
            Method: get
            PayloadFormatVersion: "2.0"

  MyAuthFunction:
    Type: AWS::Serverless::Function
    Properties:
      CodeUri: ./src
      Handler: authorizer.handler
      Runtime: nodejs12.x
```

# Contoh izin IAM untuk AWS SAM
<a name="serverless-controlling-access-to-apis-permissions"></a>

Anda dapat mengontrol akses ke Anda APIs dengan mendefinisikan izin IAM dalam template Anda. AWS SAM Untuk melakukannya, Anda menggunakan tipe data [ApiAuth](sam-property-api-apiauth.md).

Berikut ini adalah contoh AWS SAM template yang digunakan untuk izin IAM:

```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Resources:
  MyApi:
    Type: AWS::Serverless::Api
    Properties:
      StageName: Prod
      Description: 'API with IAM authorization'
      Auth:
        DefaultAuthorizer: AWS_IAM #sets AWS_IAM auth for all methods in this API
  MyFunction:
    Type: AWS::Serverless::Function
    Properties:
      Handler: index.handler
      Runtime: python3.10
      Events:
        GetRoot:
          Type: Api
          Properties:
            RestApiId: !Ref MyApi
            Path: /
            Method: get
      InlineCode: |
        def handler(event, context):
          return {'body': 'Hello World!', 'statusCode': 200}
```

Untuk informasi selengkapnya tentang izin IAM, lihat [Mengendalikan akses untuk menerapkan API](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-control-access-using-iam-policies-to-invoke-api.html) di *Panduan Developer API Gateway*.

# Contoh kumpulan pengguna Amazon Cognito untuk AWS SAM
<a name="serverless-controlling-access-to-apis-cognito-user-pool"></a>

Anda dapat mengontrol akses ke Anda APIs dengan mendefinisikan kumpulan pengguna Amazon Cognito dalam AWS SAM template Anda. Untuk melakukannya, Anda menggunakan tipe data [ApiAuth](sam-property-api-apiauth.md).

Berikut ini adalah contoh bagian AWS SAM template untuk kumpulan pengguna:

```
Resources:
  MyApi:
    Type: AWS::Serverless::Api
    Properties:
      StageName: Prod
      Cors: "'*'"
      Auth:
        DefaultAuthorizer: MyCognitoAuthorizer
        Authorizers:
          MyCognitoAuthorizer:
            UserPoolArn: !GetAtt MyCognitoUserPool.Arn

  MyFunction:
    Type: AWS::Serverless::Function
    Properties:
      CodeUri: ./src
      Handler: lambda.handler
      Runtime: nodejs12.x
      Events:
        Root:
          Type: Api
          Properties:
            RestApiId: !Ref MyApi
            Path: /
            Method: GET

  MyCognitoUserPool:
    Type: AWS::Cognito::UserPool
    Properties:
      UserPoolName: !Ref CognitoUserPoolName
      Policies:
        PasswordPolicy:
          MinimumLength: 8
      UsernameAttributes:
        - email
      Schema:
        - AttributeDataType: String
          Name: email
          Required: false
  
  MyCognitoUserPoolClient:
    Type: AWS::Cognito::UserPoolClient
    Properties:
      UserPoolId: !Ref MyCognitoUserPool
      ClientName: !Ref CognitoUserPoolClientName
      GenerateSecret: false
```

Untuk informasi selengkapnya tentang kolam pengguna Amazon Cognito, lihat [Mengendalikan akses ke REST API menggunakan kolam pengguna Amazon Cognito sebagai pemberi otorisasi](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-integrate-with-cognito.html) di *Panduan Developer API Gateway*.

# Contoh kunci API untuk AWS SAM
<a name="serverless-controlling-access-to-apis-keys"></a>

Anda dapat mengontrol akses ke Anda APIs dengan meminta kunci API dalam AWS SAM template Anda. Untuk melakukannya, Anda menggunakan tipe data [ApiAuth](sam-property-api-apiauth.md).

Berikut ini adalah contoh bagian AWS SAM template untuk kunci API:

```
Resources:
  MyApi:
    Type: AWS::Serverless::Api
    Properties:
      StageName: Prod
      Auth:
        ApiKeyRequired: true # sets for all methods

  MyFunction:
    Type: AWS::Serverless::Function
    Properties:
      CodeUri: .
      Handler: index.handler
      Runtime: nodejs12.x
      Events:
        ApiKey:
          Type: Api
          Properties:
            RestApiId: !Ref MyApi
            Path: /
            Method: get
            Auth:
              ApiKeyRequired: true
```

Untuk informasi selengkapnya tentang kunci API, lihat [Membuat dan menggunakan rencana penggunaan dengan kunci API](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-api-usage-plans.html) di *Panduan Developer API Gateway*.

# Contoh kebijakan sumber daya untuk AWS SAM
<a name="serverless-controlling-access-to-apis-resource-policies"></a>

Anda dapat mengontrol akses ke Anda APIs dengan melampirkan kebijakan sumber daya dalam AWS SAM template Anda. Untuk melakukannya, Anda menggunakan tipe data [ApiAuth](sam-property-api-apiauth.md).

Berikut ini adalah contoh AWS SAM template untuk API pribadi. API pribadi harus memiliki kebijakan sumber daya untuk diterapkan.

```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Resources:
  MyPrivateApi:
    Type: AWS::Serverless::Api
    Properties:
      StageName: Prod
      EndpointConfiguration: PRIVATE  # Creates a private API. Resource policies are required for all private APIs.
      Auth:
        ResourcePolicy:
          CustomStatements: 
            - Effect: 'Allow'
              Action: 'execute-api:Invoke'
              Resource: ['execute-api:/*/*/*']
              Principal: '*'
            - Effect: 'Deny'
              Action: 'execute-api:Invoke'
              Resource: ['execute-api:/*/*/*']
              Principal: '*'
  MyFunction:
    Type: 'AWS::Serverless::Function'
    Properties:
      InlineCode: |
        def handler(event, context):
          return {'body': 'Hello World!', 'statusCode': 200}
      Handler: index.handler
      Runtime: python3.10
      Events:
        AddItem:
          Type: Api
          Properties:
            RestApiId: 
              Ref: MyPrivateApi
            Path: /
            Method: get
```

Untuk informasi selengkapnya tentang kebijakan sumber daya, lihat [Mengendalikan akses ke API dengan kebijakan sumber daya API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-resource-policies.html) di *Panduan Developer API Gateway*. Untuk informasi selengkapnya tentang privat APIs, lihat [Membuat API pribadi di Amazon API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-private-apis.html) di *Panduan Pengembang API Gateway*.

# OAuth 2.0/JWT authorizer contoh untuk AWS SAM
<a name="serverless-controlling-access-to-apis-oauth2-authorizer"></a>

[Anda dapat mengontrol akses ke APIs penggunaan Anda JWTs sebagai bagian dari [OpenID Connect (OIDC)](https://openid.net/specs/openid-connect-core-1_0.html) dan 2.0 framework. OAuth ](https://oauth.net/2/) Untuk melakukannya, Anda menggunakan tipe data [HttpApiAuth](sam-property-httpapi-httpapiauth.md).

Berikut ini adalah contoh bagian AWS SAM template untuk OAuth 2.0/JWT authorizer:

```
Resources:
  MyApi:
    Type: AWS::Serverless::HttpApi
    Properties:
      Auth:
        Authorizers:
          MyOauth2Authorizer:
            AuthorizationScopes:
              - scope
            IdentitySource: $request.header.Authorization
            JwtConfiguration:
              audience:
                - audience1
                - audience2
              issuer: "https://www.example.com/v1/connect/oidc"
        DefaultAuthorizer: MyOauth2Authorizer
      StageName: Prod
  MyFunction:
    Type: AWS::Serverless::Function
    Properties:
      CodeUri: ./src
      Events:
        GetRoot:
          Properties:
            ApiId: MyApi
            Method: get
            Path: /
            PayloadFormatVersion: "2.0"
          Type: HttpApi
      Handler: index.handler
      Runtime: nodejs12.x
```

*Untuk informasi selengkapnya tentang otorisasi OAuth 2.0/JWT, lihat [Mengontrol akses ke HTTP APIs dengan otorisasi JWT di Panduan Pengembang API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-jwt-authorizer.html).*

# Contoh respons yang disesuaikan untuk AWS SAM
<a name="serverless-controlling-access-to-apis-customize-response"></a>

Anda dapat menyesuaikan beberapa respons kesalahan API Gateway dengan menentukan header respons dalam templat AWS SAM Anda. Untuk melakukannya, Anda menggunakan tipe data [Gateway Response Object](https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md#gateway-response-object).

Berikut ini adalah contoh AWS SAM template yang membuat respons khusus untuk `DEFAULT_5XX` kesalahan tersebut.

```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Resources:
  MyApi:
    Type: AWS::Serverless::Api
    Properties:
      StageName: Prod
      GatewayResponses:
        DEFAULT_5XX:
          ResponseParameters:
            Headers:
              Access-Control-Expose-Headers: "'WWW-Authenticate'"
              Access-Control-Allow-Origin: "'*'"
              ErrorHeader: "'MyCustomErrorHeader'"
          ResponseTemplates:
            application/json: "{\"message\": \"Error on the $context.resourcePath resource\" }"
              
  GetFunction:
    Type: AWS::Serverless::Function
    Properties:
      Runtime: python3.10
      Handler: index.handler
      InlineCode: |
        def handler(event, context):
          raise Exception('Check out the new response!')
      Events:
        GetResource:
          Type: Api
          Properties:
            Path: /error
            Method: get
            RestApiId: !Ref MyApi
```

Untuk informasi selengkapnya tentang respons API Gateway, lihat [Respon gateway di API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-gatewayResponse-definition.html) di *Panduan Developer API Gateway*.