

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::Stecker

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

Für 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).

Um Feedback zu Steckverbindern zu geben, [eine neue Ausgabe einreichen](https://github.com/aws/serverless-application-model/issues/new?assignees=&labels=area%2Fconnectors,stage%2Fneeds-triage&template=other.md&title=%28Feature%20Request%29) bei der *serverloses Anwendungsmodell AWS GitHub Endlager*.

**Anmerkung**  
Wenn Sie bereitstellen AWS CloudFormation, AWS SAM transformiert deine AWS SAM Ressourcen in CloudFormation Ressourcen. Weitere Informationen finden Sie unter [Generiert CloudFormation Ressourcen für AWS SAM](sam-specification-generated-resources.md).

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

Um diese Entität in Ihrem zu deklarieren AWS Serverless Application Model (AWS SAM) Vorlage, verwenden Sie eine der folgenden Syntaxen.

**Anmerkung**  
Für die meisten Anwendungsfälle empfehlen wir, die Syntax der eingebetteten 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 befindet AWS SAM Eine Vorlage, z. B. eine Ressource in einem verschachtelten Stapel oder eine gemeinsam genutzte Ressource, verwenden Sie die `AWS::Serverless::Connector` Syntax.

### Eingebettete Anschlüsse
<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::Stecker
<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 keine CloudFormation gleichwertig.

 `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` umfasst 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 keine CloudFormation gleichwertig.

 `Source`   <a name="sam-connector-source"></a>
Die Quellressource. Erforderlich bei der Verwendung von `AWS::Serverless::Connector` Syntax.  
*Typ:* [ResourceReference](sam-property-connector-resourcereference.md)  
*Required*: Conditional  
*CloudFormation Kompatibilität*: Diese Eigenschaft ist einzigartig für AWS SAM und hat keine CloudFormation gleichwertig.

 `SourceReference`   <a name="sam-connector-sourcereference"></a>
Die Quellressource.  
Verwenden Sie die Syntax für eingebettete Konnektoren, 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 keine CloudFormation gleichwertig.

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

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

Im folgenden Beispiel werden eingebettete Konnektoren verwendet, um einen zu definieren `Write` Datenverbindung zwischen einem AWS Lambda Event-Funktion und Amazon DynamoDB-Tabelle:

```
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 zur Definition verwendet `Read` und `Write` Genehmigungen:

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

Das folgende Beispiel verwendet eingebettete Konnektoren, um eine Quellressource mit einer anderen Eigenschaft als zu definieren `Id`:

```
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::Stecker
<a name="sam-resource-connector--examples-connector"></a>

Das folgende Beispiel verwendet [AWS::Serverless::Stecker](sam-resource-connector.md) Ressource, die Sie haben sollen AWS Lambda Funktion zum Lesen und Schreiben in eine Amazon DynamoDB-Tabelle:

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

Das folgende Beispiel verwendet [AWS::Serverless::Stecker](sam-resource-connector.md) Ressource, damit eine Lambda-Funktion in ein Amazon 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
```

Das folgende Beispiel verwendet [AWS::Serverless::Stecker](sam-resource-connector.md) Ressource, damit ein Amazon SNS-Thema in eine Lambda-Funktion geschrieben wird, 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
```

Das Folgende ist das 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"
      }
    ]
  }
}
```