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

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

Configura le autorizzazioni tra due risorse. Per un'introduzione ai connettori, vedere. [Gestione delle autorizzazioni delle risorse con i connettori AWS SAM](managing-permissions-connectors.md)

Per ulteriori informazioni sulle AWS CloudFormation risorse generate, vedere[CloudFormation risorse generate quando si specifica AWS::Serverless::Connector](sam-specification-generated-resources-connector.md).

Per fornire feedback sui connettori, [invia un nuovo problema](https://github.com/aws/serverless-application-model/issues/new?assignees=&labels=area%2Fconnectors,stage%2Fneeds-triage&template=other.md&title=%28Feature%20Request%29) al *serverless-application-model AWS GitHub repository*.

**Nota**  
Quando lo distribuisci a AWS CloudFormation, AWS SAM trasforma le tue AWS SAM risorse in risorse. CloudFormation Per ulteriori informazioni, consulta [CloudFormation Risorse generate per AWS SAM](sam-specification-generated-resources.md).

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

Per dichiarare questa entità nel tuo modello AWS Serverless Application Model (AWS SAM), usa una delle seguenti sintassi.

**Nota**  
Consigliamo di utilizzare la sintassi dei connettori incorporati per la maggior parte dei casi d'uso. Essendo incorporato nella risorsa di origine ne semplifica la lettura e la manutenzione nel tempo. Quando devi fare riferimento a una risorsa di origine che non si trova all'interno dello stesso AWS SAM modello, ad esempio una risorsa in uno stack annidato o una risorsa condivisa, usa la `AWS::Serverless::Connector` sintassi.

### Connettori incorporati
<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}}
```

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

 `Destination`   <a name="sam-connector-destination"></a>
La risorsa di destinazione.  
*Tipo*: [ResourceReference](sam-property-connector-resourcereference.md)\| Elenco di [ResourceReference](sam-property-connector-resourcereference.md)  
*Obbligatorio:* sì  
*CloudFormation compatibilità*: Questa proprietà è unica AWS SAM e non ha un CloudFormation equivalente.

 `Permissions`   <a name="sam-connector-permissions"></a>
Il tipo di autorizzazione che la risorsa di origine può eseguire sulla risorsa di destinazione.  
`Read`include azioni AWS Identity and Access Management (IAM) che consentono la lettura dei dati dalla risorsa.  
`Write`include azioni IAM che consentono l'avvio e la scrittura di dati su una risorsa.  
*Valori validi*: `Read` o `Write`  
Tipo: elenco  
*Obbligatorio:* sì  
*CloudFormation compatibilità*: questa proprietà è unica AWS SAM e non ha un CloudFormation equivalente.

 `Source`   <a name="sam-connector-source"></a>
La risorsa di origine. Richiesto quando si utilizza la `AWS::Serverless::Connector` sintassi.  
*Tipo:* [ResourceReference](sam-property-connector-resourcereference.md)  
*Required*: Conditional  
*CloudFormation compatibilità*: questa proprietà è unica AWS SAM e non ha un CloudFormation equivalente.

 `SourceReference`   <a name="sam-connector-sourcereference"></a>
La risorsa di origine.  
Da utilizzare con la sintassi dei connettori incorporati per definire proprietà aggiuntive per la risorsa di origine.
*Tipo:* [SourceReference](sam-property-connector-sourcereference.md)  
*Obbligatorio:* no  
*CloudFormation compatibilità*: questa proprietà è unica AWS SAM e non ha un CloudFormation equivalente.

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

### Connettori incorporati
<a name="sam-resource-connector-examples-embedded"></a>

L'esempio seguente utilizza connettori integrati per definire una connessione `Write` dati tra una AWS Lambda funzione e una tabella Amazon DynamoDB:

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

L'esempio seguente utilizza connettori incorporati per definire `Read` e `Write` autorizzazioni:

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

L'esempio seguente utilizza connettori incorporati per definire una risorsa di origine con una proprietà diversa `Id` da:

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

L'esempio seguente utilizza la [AWS::Serverless::Connector](#sam-resource-connector) risorsa per leggere e scrivere una AWS Lambda funzione su una tabella Amazon DynamoDB:

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

L'esempio seguente utilizza la [AWS::Serverless::Connector](#sam-resource-connector) risorsa per scrivere una funzione Lambda su un argomento Amazon SNS, con entrambe le risorse nello stesso modello:

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

L'esempio seguente utilizza la [AWS::Serverless::Connector](#sam-resource-connector) risorsa per scrivere un argomento Amazon SNS su una funzione Lambda, che quindi scrive su una tabella Amazon DynamoDB, con tutte le risorse nello stesso modello:

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

Di seguito è riportato il AWS CloudFormation modello trasformato dell'esempio precedente:

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