

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Controlla l'accesso alle API con il tuo AWS SAM modello
<a name="serverless-controlling-access-to-apis"></a>

Il controllo dell'accesso al tuo API Gateway APIs aiuta a garantire che l'applicazione serverless sia sicura e accessibile solo tramite l'autorizzazione abilitata. Puoi abilitare l'autorizzazione nel tuo AWS SAM modello per controllare chi può accedere al tuo API Gateway APIs.

AWS SAM supporta diversi meccanismi per controllare l'accesso al tuo API Gateway APIs. L'insieme di meccanismi supportati varia a seconda dei tipi `AWS::Serverless::HttpApi` di `AWS::Serverless::Api` risorse.

La tabella seguente riassume i meccanismi supportati da ciascun tipo di risorsa.


| Meccanismi per il controllo dell'accesso | AWS::Serverless::HttpApi | AWS::Serverless::Api | 
| --- | --- | --- | 
| Autorizzatori Lambda | ✓ | ✓ | 
| Autorizzazioni IAM |  | ✓ | 
| Pool di utenti Amazon Cognito | ✓ \$1 | ✓ | 
| Chiavi API |  | ✓ | 
| Policy delle risorse |  | ✓ | 
| OAuth Autorizzatori 2.0/JWT | ✓ |  | 

\$1 Puoi usare Amazon Cognito come emittente di JSON Web Token (JWT) con il tipo di risorsa. `AWS::Serverless::HttpApi`
+ **Autorizzatori Lambda: un autorizzatore** Lambda (precedentemente noto come autorizzatore personalizzato*)* è una funzione Lambda fornita per controllare l'accesso all'API. Quando viene chiamata l'API, questa funzione Lambda viene richiamata con un contesto di richiesta o un token di autorizzazione fornito dall'applicazione client. La funzione Lambda risponde se il chiamante è autorizzato a eseguire l'operazione richiesta.

  Entrambi i tipi `AWS::Serverless::HttpApi` di `AWS::Serverless::Api` risorse supportano gli autorizzatori Lambda.

  Per ulteriori informazioni sugli autorizzatori Lambda con`AWS::Serverless::HttpApi`, consulta [Working with AWS Lambda authorizers for HTTP](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-lambda-authorizer.html) nella APIs *API* Gateway Developer Guide. *Per ulteriori informazioni sugli autorizzatori Lambda con`AWS::Serverless::Api`, consulta Use API [Gateway Lambda authorizers nella](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-use-lambda-authorizer.html) API Gateway Developer Guide.*

  Per esempi di autorizzatori Lambda per entrambi i tipi di risorse, vedere. [Esempi di autorizzazioni Lambda per AWS SAM](serverless-controlling-access-to-apis-lambda-authorizer.md)

  
+ **Autorizzazioni IAM**: puoi controllare chi può richiamare la tua API utilizzando le autorizzazioni [AWS Identity and Access Management (](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_controlling.html)IAM). Gli utenti che chiamano la tua API devono essere autenticati con credenziali IAM. Le chiamate alla tua API hanno esito positivo solo se all'utente IAM è associata una policy IAM che rappresenta il chiamante dell'API, un gruppo IAM che contiene l'utente o un ruolo IAM assunto dall'utente.

  Solo il tipo di `AWS::Serverless::Api` risorsa supporta le autorizzazioni IAM.

  Per ulteriori informazioni, consulta [Controllare l'accesso a un'API con autorizzazioni IAM](https://docs.aws.amazon.com/apigateway/latest/developerguide/permissions.html) nella *Guida per sviluppatori di API Gateway*. Per vedere un esempio, consulta [Esempio di autorizzazione IAM per AWS SAM](serverless-controlling-access-to-apis-permissions.md).
+ Pool di utenti **Amazon Cognito: i pool di utenti** di Amazon Cognito sono directory di utenti in Amazon Cognito. Un client della tua API deve prima accedere a un utente al pool di utenti e ottenere un'identità o un token di accesso per l'utente. Quindi il client chiama l'API con uno dei token restituiti. La chiamata API ha esito positivo solo se il token richiesto è valido.

  Il tipo di `AWS::Serverless::Api` risorsa supporta i pool di utenti di Amazon Cognito. Il tipo di `AWS::Serverless::HttpApi` risorsa supporta l'uso di Amazon Cognito come emittente JWT.

  Per ulteriori informazioni, consulta la sezione [Control access to a REST API using Amazon Cognito user pools as authorizer (Controllo degli accessi a un'API REST utilizzando pool di utenti di Amazon Cognito come autorizzazione)](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-integrate-with-cognito.html) nella *Guida per sviluppatori di API Gateway*. Per vedere un esempio, consulta [Esempio di pool di utenti Amazon Cognito per AWS SAM](serverless-controlling-access-to-apis-cognito-user-pool.md).
+ **Chiavi API: le** chiavi API sono valori di stringhe alfanumeriche che distribuisci ai clienti sviluppatori di applicazioni per concedere l'accesso alla tua API.

  Solo il tipo di `AWS::Serverless::Api` risorsa supporta le chiavi API.

  Per ulteriori informazioni sulle chiavi API, consulta [Creazione e utilizzo di piani di utilizzo con chiavi API](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-api-usage-plans.html) nella *Guida per sviluppatori di API Gateway*. Per un esempio di chiavi API, consulta[Esempio di chiave API per AWS SAM](serverless-controlling-access-to-apis-keys.md).
+ **Politiche delle** risorse: le politiche delle risorse sono documenti di policy JSON che è possibile allegare a un'API API Gateway. Utilizza le policy relative alle risorse per controllare se un principale specificato (in genere un utente o un ruolo IAM) può richiamare l'API.

  Solo il tipo di `AWS::Serverless::Api` risorsa supporta le policy delle risorse come meccanismo per controllare l'accesso all'API Gateway APIs.

  Per ulteriori informazioni sulle politiche delle risorse, consulta [Controllare l'accesso a un'API con le politiche delle risorse di API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-resource-policies.html) nella *Guida per sviluppatori di API Gateway*. Per un esempio di politiche relative alle risorse, consulta[Esempio di policy in materia di risorse per AWS SAM](serverless-controlling-access-to-apis-resource-policies.md).
+ **OAuth Autorizzatori 2.0/JWT**[: puoi utilizzare JWTs come parte dei framework OpenID [Connect (OIDC)](https://openid.net/specs/openid-connect-core-1_0.html) e OAuth 2.0 per controllare l'accesso al tuo.](https://oauth.net/2/) APIs API Gateway convalida JWTs le richieste API inviate dai client e consente o rifiuta le richieste in base alla convalida del token e, facoltativamente, agli ambiti nel token.

  Solo il tipo di `AWS::Serverless::HttpApi` risorsa supporta gli autorizzatori 2.0/JWT. OAuth

  Per ulteriori informazioni, consulta [Controllare l'accesso a HTTP APIs con gli autorizzatori JWT](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-jwt-authorizer.html) nella *API Gateway Developer Guide*. Per vedere un esempio, consulta [OAuth Esempio di autorizzazione 2.0/JWT per AWS SAM](serverless-controlling-access-to-apis-oauth2-authorizer.md).

## Scelta di un meccanismo per controllare l'accesso
<a name="serverless-controlling-access-to-apis-choices"></a>

Il meccanismo che scegli di utilizzare per controllare l'accesso al tuo API Gateway APIs dipende da alcuni fattori. Ad esempio, se hai un progetto greenfield senza autorizzazione o configurazione del controllo degli accessi, i pool di utenti di Amazon Cognito potrebbero essere l'opzione migliore. Questo perché quando configuri i pool di utenti, configuri automaticamente anche l'autenticazione e il controllo degli accessi.

Tuttavia, se l'applicazione ha già configurato l'autenticazione, l'utilizzo degli autorizzatori Lambda potrebbe essere l'opzione migliore. Questo perché puoi chiamare il servizio di autenticazione esistente e restituire un documento di policy basato sulla risposta. Inoltre, se la tua applicazione richiede un'autenticazione personalizzata o una logica di controllo degli accessi che i pool di utenti non supportano, gli autorizzatori Lambda potrebbero essere l'opzione migliore.

Dopo aver scelto il meccanismo da utilizzare, consulta la sezione corrispondente [Esempi](#serverless-controlling-access-to-apis-examples) per scoprire come configurare l'applicazione AWS SAM per utilizzare quel meccanismo.

## Personalizzazione delle risposte agli errori
<a name="serverless-controlling-access-to-apis-responses"></a>

È possibile utilizzarlo AWS SAM per personalizzare il contenuto di alcune risposte di errore di API Gateway. Solo il tipo di `AWS::Serverless::Api` risorsa supporta risposte API Gateway personalizzate.

Per ulteriori informazioni sulle risposte di API Gateway, consulta le [risposte del gateway in API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-gatewayResponse-definition.html) nella *API Gateway Developer Guide*. Per un esempio di risposte personalizzate, consulta[Esempio di risposta personalizzata per AWS SAM](serverless-controlling-access-to-apis-customize-response.md).

## Esempi
<a name="serverless-controlling-access-to-apis-examples"></a>
+ [Esempi di autorizzazioni Lambda per AWS SAM](serverless-controlling-access-to-apis-lambda-authorizer.md)
+ [Esempio di autorizzazione IAM per AWS SAM](serverless-controlling-access-to-apis-permissions.md)
+ [Esempio di pool di utenti Amazon Cognito per AWS SAM](serverless-controlling-access-to-apis-cognito-user-pool.md)
+ [Esempio di chiave API per AWS SAM](serverless-controlling-access-to-apis-keys.md)
+ [Esempio di policy in materia di risorse per AWS SAM](serverless-controlling-access-to-apis-resource-policies.md)
+ [OAuth Esempio di autorizzazione 2.0/JWT per AWS SAM](serverless-controlling-access-to-apis-oauth2-authorizer.md)
+ [Esempio di risposta personalizzata per AWS SAM](serverless-controlling-access-to-apis-customize-response.md)

# Esempi di autorizzazioni Lambda per AWS SAM
<a name="serverless-controlling-access-to-apis-lambda-authorizer"></a>

Il tipo di `AWS::Serverless::Api` risorsa supporta due tipi di autorizzatori Lambda: autorizzatori e `TOKEN` autorizzatori. `REQUEST` Il tipo di `AWS::Serverless::HttpApi` risorsa supporta solo gli autorizzatori. `REQUEST` Di seguito sono riportati alcuni esempi di ogni tipo.

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

Puoi controllare l'accesso al tuo APIs definendo un `TOKEN` autorizzatore Lambda all'interno del tuo modello. AWS SAM A tale scopo, si utilizza il tipo di [ApiAuth](sam-property-api-apiauth.md) dati.

Di seguito è riportato un esempio di sezione AWS SAM modello per un autorizzatore Lambda: `TOKEN`

**Nota**  
Nell'esempio seguente, il SAM `FunctionRole` viene generato implicitamente.

```
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
```

*Per ulteriori informazioni sugli autorizzatori Lambda, consulta Use API [Gateway Lambda authorizers nella](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-use-lambda-authorizer.html) API Gateway Developer Guide.*

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

Puoi controllare l'accesso al tuo APIs definendo un `REQUEST` autorizzatore Lambda all'interno del tuo modello. AWS SAM A tale scopo, si utilizza il tipo di [ApiAuth](sam-property-api-apiauth.md) dati.

Di seguito è riportato un esempio di sezione AWS SAM modello per un autorizzatore 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
```

*Per ulteriori informazioni sugli autorizzatori Lambda, consulta Use API [Gateway Lambda authorizers nella](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-use-lambda-authorizer.html) API Gateway Developer Guide.*

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

Puoi controllare l'accesso al tuo HTTP APIs definendo un autorizzatore Lambda all'interno del tuo modello. AWS SAM A tale scopo, si utilizza il tipo di [HttpApiAuth](sam-property-httpapi-httpapiauth.md) dati.

Di seguito è riportato un esempio di sezione AWS SAM modello per un autorizzatore 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
```

# Esempio di autorizzazione IAM per AWS SAM
<a name="serverless-controlling-access-to-apis-permissions"></a>

Puoi controllare l'accesso al tuo APIs definendo le autorizzazioni IAM all'interno del tuo AWS SAM modello. A tale scopo, si utilizza il tipo di [ApiAuth](sam-property-api-apiauth.md) dati.

Di seguito è riportato un AWS SAM modello di esempio che utilizza per le autorizzazioni 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}
```

Per ulteriori informazioni sulle autorizzazioni IAM, consulta [Control access for invoking an API nella API](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-control-access-using-iam-policies-to-invoke-api.html) *Gateway Developer Guide*.

# Esempio di pool di utenti Amazon Cognito per AWS SAM
<a name="serverless-controlling-access-to-apis-cognito-user-pool"></a>

Puoi controllare l'accesso ai tuoi utenti APIs definendo i pool di utenti di Amazon Cognito all'interno del AWS SAM modello. Per fare ciò, usi il tipo di [ApiAuth](sam-property-api-apiauth.md) dati.

Di seguito è riportato un esempio AWS SAM di sezione modello per un pool di utenti:

```
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
```

Per ulteriori informazioni sui pool di utenti di Amazon Cognito, consulta [Controllare l'accesso a un'API REST utilizzando i pool di utenti di Amazon Cognito come](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-integrate-with-cognito.html) autorizzatore nella Guida per sviluppatori di API *Gateway*.

# Esempio di chiave API per AWS SAM
<a name="serverless-controlling-access-to-apis-keys"></a>

Puoi controllare l'accesso al tuo APIs richiedendo le chiavi API all'interno del tuo AWS SAM modello. A tale scopo, si utilizza il tipo di [ApiAuth](sam-property-api-apiauth.md) dati.

Di seguito è riportato un esempio di sezione AWS SAM modello per le chiavi 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
```

Per ulteriori informazioni sulle chiavi API, consulta [Creazione e utilizzo di piani di utilizzo con chiavi API](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-api-usage-plans.html) nella *Guida per sviluppatori di API Gateway*.

# Esempio di policy in materia di risorse per AWS SAM
<a name="serverless-controlling-access-to-apis-resource-policies"></a>

Puoi controllare l'accesso ai tuoi APIs allegando una politica delle risorse all'interno del tuo AWS SAM modello. A tale scopo, si utilizza il tipo di [ApiAuth](sam-property-api-apiauth.md) dati.

Di seguito è riportato un AWS SAM modello di esempio per un'API privata. Un'API privata deve disporre di una politica delle risorse da distribuire.

```
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
```

Per ulteriori informazioni sulle politiche delle risorse, consulta [Controllare l'accesso a un'API con le politiche delle risorse di API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-resource-policies.html) nella *Guida per sviluppatori di API Gateway*. Per ulteriori informazioni sulla privacy APIs, consulta la sezione [Creazione di un'API privata in Amazon API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-private-apis.html) nella *API Gateway Developer Guide*.

# OAuth Esempio di autorizzazione 2.0/JWT per AWS SAM
<a name="serverless-controlling-access-to-apis-oauth2-authorizer"></a>

[Puoi controllare l'accesso al tuo APIs utilizzo JWTs come parte dei framework [OpenID Connect (OIDC)](https://openid.net/specs/openid-connect-core-1_0.html) e 2.0. OAuth ](https://oauth.net/2/) A tale scopo, si utilizza il tipo di dati. [HttpApiAuth](sam-property-httpapi-httpapiauth.md)

Di seguito è riportato un esempio di sezione AWS SAM modello per un autorizzatore OAuth 2.0/JWT:

```
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
```

*Per ulteriori informazioni sugli autorizzatori OAuth 2.0/JWT, consulta [Controlling access to HTTP APIs with JWT authorizers nella](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-jwt-authorizer.html) API Gateway Developer Guide.*

# Esempio di risposta personalizzata per AWS SAM
<a name="serverless-controlling-access-to-apis-customize-response"></a>

Puoi personalizzare alcune risposte di errore di API Gateway definendo le intestazioni di risposta all'interno del tuo AWS SAM modello. A tale scopo, si utilizza il tipo di dati [Gateway Response Object](https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md#gateway-response-object).

Di seguito è riportato un AWS SAM modello di esempio che crea una risposta personalizzata per l'`DEFAULT_5XX`errore.

```
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
```

Per ulteriori informazioni sulle risposte di API Gateway, consulta le [risposte del gateway in API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-gatewayResponse-definition.html) nella *API Gateway Developer Guide*.