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.

# AWS::Serverless::Connector
<a name="sam-resource-connector"></a>

Konfiguriert Berechtigungen zwischen zwei Ressourcen. Eine Einführung in Konnektoren finden Sie unter[Verwaltung von Ressourcenberechtigungen mit AWS SAM Konnektoren](managing-permissions-connectors.md).

Weitere Informationen zu generierten AWS CloudFormation Ressourcen finden Sie unter[CloudFormation Ressourcen, die generiert werden, wenn Sie angeben AWS::Serverless::Connector](sam-specification-generated-resources-connector.md).

Wenn Sie Feedback zu Konnektoren geben möchten, [reichen Sie eine neue Ausgabe](https://github.com/aws/serverless-application-model/issues/new?assignees=&labels=area%2Fconnectors,stage%2Fneeds-triage&template=other.md&title=%28Feature%20Request%29) im *serverless-application-model AWS GitHub Repository* ein.

**Anmerkung**  
Wenn Sie auf bereitstellen AWS CloudFormation, werden Ihre AWS SAM Ressourcen in AWS SAM CloudFormation Ressourcen umgewandelt. Weitere Informationen finden Sie unter [Generierte CloudFormation Ressourcen für AWS SAM](sam-specification-generated-resources.md).

## Syntax
<a name="sam-resource-connector-syntax"></a>

Verwenden Sie eine der folgenden Syntaxen, um diese Entität in Ihrer Vorlage AWS Serverless Application Model (AWS SAM) zu deklarieren.

**Anmerkung**  
Für die meisten Anwendungsfälle empfehlen wir, die Syntax für eingebettete Konnektoren zu verwenden. Da sie in die Quellressource eingebettet ist, ist sie im Laufe der Zeit einfacher zu lesen und zu verwalten. Wenn Sie auf eine Quellressource verweisen müssen, die sich nicht in derselben AWS SAM Vorlage befindet, z. B. eine Ressource in einem verschachtelten Stapel oder eine gemeinsam genutzte Ressource, verwenden Sie die `AWS::Serverless::Connector` Syntax.

### Integrierte Konnektoren
<a name="sam-resource-connector-syntax-embedded"></a>

```
{{<source-resource-logical-id>}}:
  Connectors:
    {{<connector-logical-id}}:
      Properties:
        [Destination](#sam-connector-destination): {{ResourceReference}} | {{List of ResourceReference}}
        [Permissions](#sam-connector-permissions): {{List}}
        [SourceReference](#sam-connector-sourcereference): {{SourceReference}}
```

### AWS::Serverless::Connector
<a name="sam-resource-connector-syntax-connector"></a>

```
Type: AWS::Serverless::Connector
Properties:
  [Destination](#sam-connector-destination): {{ResourceReference}} | {{List of ResourceReference}}
  [Permissions](#sam-connector-permissions): {{List}}
  [Source](#sam-connector-source): {{ResourceReference}}
```

## Eigenschaften
<a name="sam-resource-connector-properties"></a>

 `Destination`   <a name="sam-connector-destination"></a>
Die Zielressource.  
*Typ*: [ResourceReference](sam-property-connector-resourcereference.md)\| Liste von [ResourceReference](sam-property-connector-resourcereference.md)  
*Erforderlich*: Ja  
*CloudFormation Kompatibilität*: Diese Eigenschaft ist einzigartig für AWS SAM und hat kein CloudFormation Äquivalent.

 `Permissions`   <a name="sam-connector-permissions"></a>
Der Berechtigungstyp, den die Quellressource für die Zielressource ausführen darf.  
`Read`beinhaltet AWS Identity and Access Management (IAM) -Aktionen, die das Lesen von Daten aus der Ressource ermöglichen.  
`Write`beinhaltet IAM-Aktionen, die das Initiieren und Schreiben von Daten in eine Ressource ermöglichen.  
*Zulässige Werte*: `Read` oder `Write`.  
*Typ*: Liste  
*Erforderlich*: Ja  
*CloudFormation Kompatibilität*: Diese Eigenschaft ist einzigartig für AWS SAM und hat kein Äquivalent. CloudFormation 

 `Source`   <a name="sam-connector-source"></a>
Die Quellressource. Erforderlich, wenn die `AWS::Serverless::Connector` Syntax verwendet wird.  
*Typ:* [ResourceReference](sam-property-connector-resourcereference.md)  
*Required*: Conditional  
*CloudFormation Kompatibilität*: Diese Eigenschaft ist einzigartig für AWS SAM und hat kein CloudFormation Äquivalent.

 `SourceReference`   <a name="sam-connector-sourcereference"></a>
Die Quellressource.  
Wird zusammen mit der Syntax der eingebetteten Konnektoren verwendet, wenn Sie zusätzliche Eigenschaften für die Quellressource definieren.
*Typ:* [SourceReference](sam-property-connector-sourcereference.md)  
*Required*: No  
*CloudFormation Kompatibilität*: Diese Eigenschaft ist einzigartig für AWS SAM und hat kein CloudFormation Äquivalent.

## Beispiele
<a name="sam-resource-connector-examples"></a>

### Eingebettete Anschlüsse
<a name="sam-resource-connector-examples-embedded"></a>

Das folgende Beispiel verwendet eingebettete Konnektoren, um eine `Write` Datenverbindung zwischen einer AWS Lambda Funktion und einer Amazon DynamoDB-Tabelle zu definieren:

```
Transform: AWS::Serverless-2016-10-31
...
Resources:
  MyTable:
    Type: AWS::Serverless::SimpleTable
  MyFunction:
    Type: AWS::Serverless::Function
    Connectors:
      MyConn:
        Properties:
          Destination:
            Id: MyTable
          Permissions:
            - Write
    ...
```

Im folgenden Beispiel werden eingebettete Konnektoren verwendet, um Berechtigungen zu definieren`Read`: `Write`

```
Transform: AWS::Serverless-2016-10-31
...
Resources:
  MyFunction:
    Type: AWS::Serverless::Function
    Connectors:
      MyConn:
        Properties:
          Destination:
            Id: MyTable
          Permissions:
            - Read
            - Write
  MyTable:
    Type: AWS::DynamoDB::Table
    ...
```

Im folgenden Beispiel werden eingebettete Konnektoren verwendet, um eine Quellressource mit einer anderen Eigenschaft als zu definieren`Id`:

```
Transform: AWS::Serverless-2016-10-31
Transform: AWS::Serverless-2016-10-31
...
Resources:
  MyApi:
    Type: AWS::Serverless::Api
    Connectors:
      ApitoLambdaConn:
        Properties:
          SourceReference:
            Qualifier: Prod/GET/foobar
          Destination:
            Id: MyTable
          Permissions:
            - Read
            - Write
  MyTable:
    Type: AWS::DynamoDB::Table
    ...
```

### AWS::Serverless::Connector
<a name="sam-resource-connector--examples-connector"></a>

Im folgenden Beispiel wird die [AWS::Serverless::Connector](#sam-resource-connector) Ressource verwendet, damit eine AWS Lambda Funktion aus einer Amazon DynamoDB-Tabelle liest und in diese schreibt:

```
MyConnector:
  Type: AWS::Serverless::Connector
  Properties:
    Source:
      Id: MyFunction
    Destination:
      Id: MyTable
    Permissions:
      - Read
      - Write
```

Im folgenden Beispiel wird die [AWS::Serverless::Connector](#sam-resource-connector) Ressource verwendet, damit eine Lambda-Funktion in ein Amazon SNS SNS-Thema schreibt, wobei sich beide Ressourcen in derselben Vorlage befinden:

```
MyConnector:
  Type: AWS::Serverless::Connector
  Properties:
    Source:
      Id: MyLambda
    Destination:
      Id: MySNSTopic
    Permissions:
      - Write
```

Im folgenden Beispiel wird die [AWS::Serverless::Connector](#sam-resource-connector) Ressource verwendet, um ein Amazon SNS SNS-Thema in eine Lambda-Funktion schreiben zu lassen, die dann in eine Amazon DynamoDB-Tabelle schreibt, wobei sich alle Ressourcen in derselben Vorlage befinden:

```
Transform: AWS::Serverless-2016-10-31
Resources:
  Topic:
    Type: AWS::SNS::Topic
    Properties:
      Subscription:
        - Endpoint: !GetAtt Function.Arn
          Protocol: lambda

  Function:
    Type: AWS::Serverless::Function
    Properties:
      Runtime: nodejs16.x
      Handler: index.handler
      InlineCode: |
        const AWS = require('aws-sdk');
        exports.handler = async (event, context) => {
          const docClient = new AWS.DynamoDB.DocumentClient();
          await docClient.put({ 
            TableName: process.env.TABLE_NAME, 
            Item: {
              id: context.awsRequestId,
              event: JSON.stringify(event)
            }
          }).promise();
        };
      Environment:
        Variables:
          TABLE_NAME: !Ref Table

  Table:
    Type: AWS::Serverless::SimpleTable

  TopicToFunctionConnector:
    Type: AWS::Serverless::Connector
    Properties:
      Source: 
        Id: Topic
      Destination: 
        Id: Function
      Permissions:
        - Write

  FunctionToTableConnector:
    Type: AWS::Serverless::Connector
    Properties:
      Source: 
        Id: Function
      Destination: 
        Id: Table
      Permissions:
        - Write
```

Im Folgenden sehen Sie die transformierte AWS CloudFormation Vorlage aus dem obigen Beispiel:

```
"FunctionToTableConnectorPolicy": {
  "Type": "AWS::IAM::ManagedPolicy",
  "Metadata": {
    "aws:sam:connectors": {
      "FunctionToTableConnector": {
        "Source": {
          "Type": "AWS::Lambda::Function"
        },
        "Destination": {
          "Type": "AWS::DynamoDB::Table"
        }
      }
    }
  },
  "Properties": {
    "PolicyDocument": {
      "Version": "2012-10-17",		 	 	 
      "Statement": [
        {
          "Effect": "Allow",
          "Action": [
            "dynamodb:PutItem",
            "dynamodb:UpdateItem",
            "dynamodb:DeleteItem",
            "dynamodb:BatchWriteItem",
            "dynamodb:PartiQLDelete",
            "dynamodb:PartiQLInsert",
            "dynamodb:PartiQLUpdate"
          ],
          "Resource": [
            {
              "Fn::GetAtt": [
                "MyTable",
                "Arn"
              ]
            },
            {
              "Fn::Sub": [
                "${DestinationArn}/index/*",
                {
                  "DestinationArn": {
                    "Fn::GetAtt": [
                      "MyTable",
                      "Arn"
                    ]
                  }
                }
              ]
            }
          ]
        }
      ]
    },
    "Roles": [
      {
        "Ref": "MyFunctionRole"
      }
    ]
  }
}
```