

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Kontrollieren Sie den API-Zugriff mit Ihrer AWS SAM Vorlage
<a name="serverless-controlling-access-to-apis"></a>

Durch die Steuerung des Zugriffs auf Ihr API Gateway wird APIs sichergestellt, dass Ihre serverlose Anwendung sicher ist und nur mit der von Ihnen aktivierten Autorisierung darauf zugegriffen werden kann. Sie können die Autorisierung in Ihrer AWS SAM Vorlage aktivieren, um zu kontrollieren, wer auf Ihr API Gateway zugreifen kann APIs.

AWS SAM unterstützt mehrere Mechanismen zur Steuerung des Zugriffs auf Ihr API Gateway APIs. Die unterstützten Mechanismen unterscheiden `AWS::Serverless::HttpApi` sich je nach `AWS::Serverless::Api` Ressourcentyp.

In der folgenden Tabelle sind die Mechanismen zusammengefasst, die von den einzelnen Ressourcentypen unterstützt werden.


| Mechanismen zur Zugriffskontrolle | AWS::Serverless::HttpApi | AWS::Serverless::Api | 
| --- | --- | --- | 
| Lambda-Autorisierer | ✓ | ✓ | 
| IAM-Berechtigungen |  | ✓ | 
| Amazon-Cognito-Benutzerpools | ✓ \$1 | ✓ | 
| API-Schlüssel |  | ✓ | 
| Ressourcenrichtlinien |  | ✓ | 
| OAuth 2.0/JWT-Autorisierer | ✓ |  | 

\$1 Sie können Amazon Cognito als Aussteller von JSON Web Token (JWT) mit dem `AWS::Serverless::HttpApi` Ressourcentyp verwenden.
+ **Lambda-Autorisierer** — Ein Lambda-Autorisierer (früher bekannt als *benutzerdefinierter Autorisierer*) ist eine Lambda-Funktion, die Sie bereitstellen, um den Zugriff auf Ihre API zu kontrollieren. Wenn Ihre API aufgerufen wird, wird diese Lambda-Funktion mit einem Anforderungskontext oder einem Autorisierungstoken aufgerufen, das die Client-Anwendung bereitstellt. Die Lambda-Funktion gibt an, ob der Aufrufer berechtigt ist, den angeforderten Vorgang auszuführen.

  `AWS::Serverless::HttpApi`Sowohl der Ressourcentyp als auch der `AWS::Serverless::Api` Ressourcentyp unterstützen Lambda-Autorisierer.

  *Weitere Informationen zu Lambda-Autorisierern mit finden Sie unter [Arbeiten mit `AWS::Serverless::HttpApi`AWS Lambda Autorisierern für HTTP APIs](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-lambda-authorizer.html) im API Gateway Developer Guide.* *Weitere Informationen zu Lambda-Autorisierern mit `AWS::Serverless::Api` finden Sie unter [Verwenden von API Gateway-Lambda-Autorisierern im API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-use-lambda-authorizer.html) Developer Guide.*

  Beispiele für Lambda-Autorisierer für beide Ressourcentypen finden Sie unter. [Beispiele für Lambda-Autorisierer für AWS SAM](serverless-controlling-access-to-apis-lambda-authorizer.md)

  
+ **IAM-Berechtigungen** [— Sie können mithilfe von (IAM-) Berechtigungen steuern, wer Ihre API AWS Identity and Access Management aufrufen kann.](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_controlling.html) Benutzer, die Ihre API aufrufen, müssen mit IAM-Anmeldeinformationen authentifiziert werden. Aufrufe Ihrer API sind nur erfolgreich, wenn dem IAM-Benutzer eine IAM-Richtlinie zugeordnet ist, die den API-Aufrufer repräsentiert, eine IAM-Gruppe, die den Benutzer enthält, oder eine IAM-Rolle, die der Benutzer annimmt.

  Nur der `AWS::Serverless::Api` Ressourcentyp unterstützt IAM-Berechtigungen.

  Weitere Informationen finden Sie unter [Steuern des Zugriffs auf eine API mit IAM-Berechtigungen](https://docs.aws.amazon.com/apigateway/latest/developerguide/permissions.html) im *API Gateway Developer Guide*. Ein Beispiel finden Sie unter [Beispiel für eine IAM-Berechtigung für AWS SAM](serverless-controlling-access-to-apis-permissions.md).
+ **Amazon Cognito-Benutzerpools** — Amazon Cognito Cognito-Benutzerpools sind Benutzerverzeichnisse in Amazon Cognito. Ein Client Ihrer API muss zuerst einen Benutzer beim Benutzerpool anmelden und ein Identitäts- oder Zugriffstoken für den Benutzer erhalten. Dann ruft der Client Ihre API mit einem der zurückgegebenen Token auf. Der API-Aufruf ist nur erfolgreich, wenn das erforderliche Token gültig ist.

  Der `AWS::Serverless::Api` Ressourcentyp unterstützt Amazon Cognito Cognito-Benutzerpools. Der `AWS::Serverless::HttpApi` Ressourcentyp unterstützt die Verwendung von Amazon Cognito als JWT-Emittenten.

  Weitere Informationen finden Sie unter [Control access to a REST API using Amazon cognito user pools as authorizer](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-integrate-with-cognito.html) (Zugriff auf eine REST-API mit Amazon-Cognito-Benutzerpools als Autorisierer) im *Entwicklerhandbuch von API Gateway*. Ein Beispiel finden Sie unter [Beispiel für einen Amazon Cognito Cognito-Benutzerpool für AWS SAM](serverless-controlling-access-to-apis-cognito-user-pool.md).
+ **API-Schlüssel** — API-Schlüssel sind alphanumerische Zeichenkettenwerte, die Sie an Kunden von Anwendungsentwicklern verteilen, um Zugriff auf Ihre API zu gewähren.

  Nur der `AWS::Serverless::Api` Ressourcentyp unterstützt API-Schlüssel.

  Weitere Informationen zu API-Schlüsseln finden Sie unter [Nutzungspläne mit API-Schlüsseln erstellen und verwenden](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-api-usage-plans.html) im *API Gateway Developer Guide*. Ein Beispiel für API-Schlüssel finden Sie unter[Beispiel für einen API-Schlüssel AWS SAM](serverless-controlling-access-to-apis-keys.md).
+ **Ressourcenrichtlinien** — Ressourcenrichtlinien sind JSON-Richtliniendokumente, die Sie an eine API Gateway anhängen können. Verwenden Sie Ressourcenrichtlinien, um zu steuern, ob ein bestimmter Prinzipal (normalerweise ein IAM-Benutzer oder eine IAM-Rolle) die API aufrufen kann.

  Nur der `AWS::Serverless::Api` Ressourcentyp unterstützt Ressourcenrichtlinien als Mechanismus zur Steuerung des Zugriffs auf API Gateway APIs.

  Weitere Informationen zu Ressourcenrichtlinien finden Sie unter [Steuern des Zugriffs auf eine API mit API-Gateway-Ressourcenrichtlinien](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-resource-policies.html) im *API Gateway Developer Guide*. Ein Beispiel für Ressourcenrichtlinien finden Sie unter[Beispiel für eine Ressourcenrichtlinie für AWS SAM](serverless-controlling-access-to-apis-resource-policies.md).
+ **OAuth 2.0/JWT-Autorisierer** [— Sie können sie JWTs als Teil der [OpenID Connect (OIDC)](https://openid.net/specs/openid-connect-core-1_0.html) - und OAuth 2.0-Frameworks verwenden, um den Zugriff auf Ihre zu kontrollieren.](https://oauth.net/2/) APIs API Gateway validiert die JWTs , die Clients mit API-Anfragen einreichen, und erlaubt oder lehnt Anfragen auf der Grundlage der Tokenvalidierung und optional der Bereiche im Token ab.

  Nur der `AWS::Serverless::HttpApi` Ressourcentyp unterstützt OAuth 2.0/JWT-Autorisierer.

  Weitere Informationen finden Sie unter [Steuern des Zugriffs auf HTTP APIs mit JWT-Autorisierern](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-jwt-authorizer.html) im *API Gateway* Developer Guide. Ein Beispiel finden Sie unter [OAuth 2.0/JWT-Autorisierungsbeispiel für AWS SAM](serverless-controlling-access-to-apis-oauth2-authorizer.md).

## Auswahl eines Mechanismus zur Zugriffskontrolle
<a name="serverless-controlling-access-to-apis-choices"></a>

Der Mechanismus, den Sie für die Steuerung des Zugriffs auf Ihr API Gateway verwenden, APIs hängt von einigen Faktoren ab. Wenn Sie beispielsweise ein Projekt auf der grünen Wiese haben, für das weder Autorisierung noch Zugriffskontrolle eingerichtet sind, sind Amazon Cognito Cognito-Benutzerpools möglicherweise die beste Option. Das liegt daran, dass Sie bei der Einrichtung von Benutzerpools auch automatisch sowohl die Authentifizierung als auch die Zugriffskontrolle einrichten.

Wenn für Ihre Anwendung jedoch bereits eine Authentifizierung eingerichtet ist, ist die Verwendung von Lambda-Autorisierern möglicherweise die beste Option. Dies liegt daran, dass Sie Ihren bestehenden Authentifizierungsdienst anrufen und auf der Grundlage der Antwort ein Richtliniendokument zurücksenden können. Wenn Ihre Anwendung eine benutzerdefinierte Authentifizierungs- oder Zugriffskontrolllogik erfordert, die Benutzerpools nicht unterstützen, sind Lambda-Autorisierer möglicherweise die beste Option.

Wenn Sie den zu verwendenden Mechanismus ausgewählt haben, finden Sie im entsprechenden Abschnitt unter Informationen AWS SAM zur Konfiguration Ihrer Anwendung [Beispiele](#serverless-controlling-access-to-apis-examples) für die Verwendung dieses Mechanismus.

## Anpassen von Fehlerantworten
<a name="serverless-controlling-access-to-apis-responses"></a>

Sie können AWS SAM damit den Inhalt einiger API-Gateway-Fehlerantworten anpassen. Nur der `AWS::Serverless::Api` Ressourcentyp unterstützt benutzerdefinierte API-Gateway-Antworten.

Weitere Informationen zu API-Gateway-Antworten finden Sie unter [Gateway-Antworten in API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-gatewayResponse-definition.html) im *API Gateway Developer Guide*. Ein Beispiel für benutzerdefinierte Antworten finden Sie unter[Beispiel für eine benutzerdefinierte Antwort für AWS SAM](serverless-controlling-access-to-apis-customize-response.md).

## Beispiele
<a name="serverless-controlling-access-to-apis-examples"></a>
+ [Beispiele für Lambda-Autorisierer für AWS SAM](serverless-controlling-access-to-apis-lambda-authorizer.md)
+ [Beispiel für eine IAM-Berechtigung für AWS SAM](serverless-controlling-access-to-apis-permissions.md)
+ [Beispiel für einen Amazon Cognito Cognito-Benutzerpool für AWS SAM](serverless-controlling-access-to-apis-cognito-user-pool.md)
+ [Beispiel für einen API-Schlüssel AWS SAM](serverless-controlling-access-to-apis-keys.md)
+ [Beispiel für eine Ressourcenrichtlinie für AWS SAM](serverless-controlling-access-to-apis-resource-policies.md)
+ [OAuth 2.0/JWT-Autorisierungsbeispiel für AWS SAM](serverless-controlling-access-to-apis-oauth2-authorizer.md)
+ [Beispiel für eine benutzerdefinierte Antwort für AWS SAM](serverless-controlling-access-to-apis-customize-response.md)

# Beispiele für Lambda-Autorisierer für AWS SAM
<a name="serverless-controlling-access-to-apis-lambda-authorizer"></a>

Der `AWS::Serverless::Api` Ressourcentyp unterstützt zwei Arten von Lambda-Autorisierern: Autorisierer und `TOKEN` Autorisierer. `REQUEST` Der Ressourcentyp unterstützt nur Autorisierer. `AWS::Serverless::HttpApi` `REQUEST` Im Folgenden finden Sie Beispiele für jeden Typ.

## Beispiel für einen `TOKEN` Lambda-Authorizer () AWS::Serverless::Api
<a name="serverless-controlling-access-to-apis-lambda-token-authorizer"></a>

Sie können den Zugriff auf Ihre steuern, APIs indem Sie in Ihrer AWS SAM Vorlage einen `TOKEN` Lambda-Autorisierer definieren. Dazu verwenden Sie den [ApiAuth](sam-property-api-apiauth.md) Datentyp.

Im Folgenden finden Sie ein Beispiel für einen AWS SAM Vorlagenabschnitt für einen `TOKEN` Lambda-Autorisierer:

**Anmerkung**  
Im folgenden Beispiel wird das SAM implizit `FunctionRole` generiert.

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

*Weitere Informationen zu Lambda-Autorisierern finden Sie unter [Verwenden von API Gateway-Lambda-Autorisierern im API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-use-lambda-authorizer.html) Developer Guide.*

## Beispiel für einen `REQUEST` Lambda-Authorizer () AWS::Serverless::Api
<a name="serverless-controlling-access-to-apis-lambda-request-authorizer"></a>

Sie können den Zugriff auf Ihre steuern, APIs indem Sie in Ihrer AWS SAM Vorlage einen `REQUEST` Lambda-Autorisierer definieren. Dazu verwenden Sie den [ApiAuth](sam-property-api-apiauth.md) Datentyp.

Im Folgenden finden Sie ein Beispiel für einen AWS SAM Vorlagenabschnitt für einen `REQUEST` Lambda-Autorisierer:

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

*Weitere Informationen zu Lambda-Autorisierern finden Sie unter [Verwenden von API Gateway-Lambda-Autorisierern im API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-use-lambda-authorizer.html) Developer Guide.*

## Beispiel für einen Lambda-Authorizer () AWS::Serverless::HttpApi
<a name="serverless-controlling-access-to-apis-lambda-authorizer-httpapi"></a>

Sie können den Zugriff auf Ihr HTTP steuern, APIs indem Sie in Ihrer AWS SAM Vorlage einen Lambda-Authorizer definieren. Dazu verwenden Sie den [HttpApiAuth](sam-property-httpapi-httpapiauth.md) Datentyp.

Im Folgenden finden Sie ein Beispiel für einen AWS SAM Vorlagenabschnitt für einen Lambda-Autorisierer:

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

# Beispiel für eine IAM-Berechtigung für AWS SAM
<a name="serverless-controlling-access-to-apis-permissions"></a>

Sie können den Zugriff auf Ihre steuern, APIs indem Sie IAM-Berechtigungen in Ihrer AWS SAM Vorlage definieren. Dazu verwenden Sie den [ApiAuth](sam-property-api-apiauth.md) Datentyp.

Im Folgenden finden Sie eine AWS SAM Beispielvorlage, die für IAM-Berechtigungen verwendet wird:

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

Weitere Informationen zu IAM-Berechtigungen finden Sie unter [Zugriffskontrolle für das Aufrufen einer API im API](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-control-access-using-iam-policies-to-invoke-api.html) *Gateway Developer Guide*.

# Beispiel für einen Amazon Cognito Cognito-Benutzerpool für AWS SAM
<a name="serverless-controlling-access-to-apis-cognito-user-pool"></a>

Sie können den Zugriff auf Ihre steuern, APIs indem Sie Amazon Cognito Cognito-Benutzerpools in Ihrer AWS SAM Vorlage definieren. Dazu verwenden Sie den [ApiAuth](sam-property-api-apiauth.md) Datentyp.

Im Folgenden finden Sie ein Beispiel für einen AWS SAM Vorlagenabschnitt für einen Benutzerpool:

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

Weitere Informationen zu Amazon Cognito Cognito-Benutzerpools finden Sie unter [Steuern des Zugriffs auf eine REST-API mithilfe von Amazon Cognito Cognito-Benutzerpools als Autorisierer](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-integrate-with-cognito.html) im *API Gateway* Developer Guide.

# Beispiel für einen API-Schlüssel AWS SAM
<a name="serverless-controlling-access-to-apis-keys"></a>

Sie können den Zugriff auf Ihre steuern, APIs indem Sie API-Schlüssel in Ihrer AWS SAM Vorlage angeben. Dazu verwenden Sie den [ApiAuth](sam-property-api-apiauth.md) Datentyp.

Im Folgenden finden Sie ein Beispiel für einen AWS SAM Vorlagenabschnitt für API-Schlüssel:

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

Weitere Informationen zu API-Schlüsseln finden Sie unter [Nutzungspläne mit API-Schlüsseln erstellen und verwenden](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-api-usage-plans.html) im *API Gateway Developer Guide*.

# Beispiel für eine Ressourcenrichtlinie für AWS SAM
<a name="serverless-controlling-access-to-apis-resource-policies"></a>

Sie können den Zugriff auf Ihre steuern, APIs indem Sie Ihrer AWS SAM Vorlage eine Ressourcenrichtlinie anhängen. Dazu verwenden Sie den [ApiAuth](sam-property-api-apiauth.md) Datentyp.

Im Folgenden finden Sie eine AWS SAM Beispielvorlage für eine private API. Eine private API muss über eine Ressourcenrichtlinie verfügen, damit sie bereitgestellt werden kann.

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

Weitere Informationen zu Ressourcenrichtlinien finden Sie unter [Steuern des Zugriffs auf eine API mit API-Gateway-Ressourcenrichtlinien](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-resource-policies.html) im *API Gateway Developer Guide*. Weitere Informationen zu Private APIs finden Sie unter [Creating a private API in Amazon API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-private-apis.html) im *API Gateway Developer Guide*.

# OAuth 2.0/JWT-Autorisierungsbeispiel für AWS SAM
<a name="serverless-controlling-access-to-apis-oauth2-authorizer"></a>

[Sie können den Zugriff auf Ihre APIs Nutzung JWTs als Teil der Frameworks [OpenID Connect (OIDC)](https://openid.net/specs/openid-connect-core-1_0.html) und OAuth 2.0 kontrollieren.](https://oauth.net/2/) Dazu verwenden Sie den Datentyp. [HttpApiAuth](sam-property-httpapi-httpapiauth.md)

Im Folgenden finden Sie ein Beispiel für einen AWS SAM Vorlagenabschnitt für einen 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
```

*Weitere Informationen zu OAuth 2.0/JWT-Autorisierern finden Sie unter [Steuern des Zugriffs auf HTTP APIs mit JWT-Autorisierern](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-jwt-authorizer.html) im API Gateway Developer Guide.*

# Beispiel für eine benutzerdefinierte Antwort für AWS SAM
<a name="serverless-controlling-access-to-apis-customize-response"></a>

Sie können einige API-Gateway-Fehlerantworten anpassen, indem Sie Antwortheader in Ihrer AWS SAM Vorlage definieren. Dazu verwenden Sie den Datentyp [Gateway Response Object](https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md#gateway-response-object).

Im Folgenden finden Sie eine AWS SAM Beispielvorlage, die eine benutzerdefinierte Antwort für den `DEFAULT_5XX` Fehler erstellt.

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

Weitere Informationen zu API-Gateway-Antworten finden Sie unter [Gateway-Antworten in API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-gatewayResponse-definition.html) im *API Gateway Developer Guide*.