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

# Aumenta l'efficienza utilizzando i livelli Lambda con AWS SAM
<a name="serverless-sam-cli-layers"></a>

Utilizzando AWS SAM, è possibile includere livelli nelle applicazioni serverless. AWS Lambda i livelli consentono di estrarre il codice da una funzione Lambda in un livello Lambda che può quindi essere utilizzato in diverse funzioni Lambda. In questo modo è possibile ridurre le dimensioni dei pacchetti di distribuzione, separare la logica delle funzioni principali dalle dipendenze e condividere le dipendenze tra più funzioni. Per ulteriori informazioni sui layer, consulta i [layer Lambda](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html) nella *AWS Lambda Developer* Guide.

Questo argomento fornisce informazioni su quanto segue:
+ Inclusione di livelli nell'applicazione
+ In che modo i livelli vengono memorizzati nella cache locale

Per informazioni sulla creazione di livelli personalizzati, consulta[Creazione di livelli Lambda in AWS SAM](building-layers.md).

## Inclusione di livelli nell'applicazione
<a name="including-layers"></a>

Per includere livelli nell'applicazione, utilizzate la `Layers` proprietà del tipo di [AWS::Serverless::Function](sam-resource-function.md) risorsa.

Di seguito è riportato un AWS SAM modello di esempio con una funzione Lambda che include un livello:

```
ServerlessFunction:
  Type: AWS::Serverless::Function
  Properties:
    CodeUri: .
    Handler: my_handler
    Runtime: Python3.7
    Layers:
        - <LayerVersion ARN>
```

## Come i livelli vengono memorizzati nella cache locale
<a name="local-testing-with-layers"></a>

Quando si richiama la funzione utilizzando uno dei `sam local` comandi, il pacchetto layers della funzione viene scaricato e memorizzato nella cache sull'host locale.

La tabella seguente mostra le posizioni delle directory di cache predefinite per diversi sistemi operativi.


****  

| Sistema operativo | Location (Ubicazione) | 
| --- | --- | 
| Windows 7 | C:\$1Users\$1<user>\$1AppData\$1Roaming\$1AWS SAM | 
| Windows 8 | C:\$1Users\$1<user>\$1AppData\$1Roaming\$1AWS SAM | 
| Windows 10 | C:\$1Users\$1<user>\$1AppData\$1Roaming\$1AWS SAM | 
| macOS | \$1/.aws-sam/layers-pkg | 
| Unix | \$1/.aws-sam/layers-pkg | 

Dopo che il pacchetto è stato memorizzato nella cache, AWS SAMCLI sovrappone i livelli su un'immagine Docker utilizzata per richiamare la funzione. AWS SAMCLIGenera i nomi delle immagini che crea, oltre a LayerVersions quelle conservate nella cache. Puoi trovare maggiori dettagli sullo schema nelle seguenti sezioni.

Per ispezionare i livelli sovrapposti, esegui il seguente comando per avviare una sessione bash nell'immagine che vuoi ispezionare:

```
docker run -it --entrypoint=/bin/bash samcli/lambda:<Tag following the schema outlined in Docker Image Tag Schema> -i
```

**Schema dei nomi della Layer Caching Directory**

 LayerVersionArn Dato un valore definito nel modello, AWS SAMCLI estrae la versione LayerName and dall'ARN. Crea una directory in cui inserire il contenuto del livello in named. `LayerName-Version-<first 10 characters of sha256 of ARN>`

Esempio:

```
ARN = arn:aws:lambda:us-west-2:111111111111:layer:myLayer:1
Directory name = myLayer-1-926eeb5ff1
```

**Schema di tag Docker Images**

Per calcolare l'hash univoco dei livelli, combina tutti i nomi univoci dei livelli con un delimitatore «-», prendi l' SHA256 hash e poi prendi i primi 10 caratteri.

Esempio:

```
ServerlessFunction:
  Type: AWS::Serverless::Function
  Properties:
    CodeUri: .
    Handler: my_handler
    Runtime: Python3.7
    Layers:
        - arn:aws:lambda:us-west-2:111111111111:layer:myLayer:1
        - arn:aws:lambda:us-west-2:111111111111:layer:mySecondLayer:1
```

I nomi univoci vengono calcolati nello stesso modo dello schema dei nomi di Layer Caching Directory:

```
arn:aws:lambda:us-west-2:111111111111:layer:myLayer:1 = myLayer-1-926eeb5ff1
arn:aws:lambda:us-west-2:111111111111:layer:mySecondLayer:1 = mySecondLayer-1-6bc1022bdf
```

Per calcolare l'hash univoco dei livelli, combina tutti i nomi univoci dei livelli con un delimitatore '-', prendi l'hash sha256 e poi prendi i primi 25 caratteri:

```
myLayer-1-926eeb5ff1-mySecondLayer-1-6bc1022bdf = 2dd7ac5ffb30d515926aef
```

Quindi combina questo valore con il runtime e l'architettura della funzione, con un delimitatore di '-':

```
python3.7-x86_64-2dd7ac5ffb30d515926aefffd
```