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

# Creazione di livelli Lambda in AWS SAM
<a name="building-layers"></a>



Puoi usarlo AWS SAM per creare layer Lambda personalizzati. I layer Lambda consentono di estrarre codice da una funzione Lambda che può quindi essere riutilizzato in diverse funzioni Lambda. La creazione di soli livelli Lambda (anziché la creazione dell'intera applicazione) può apportare vantaggi in alcuni modi. Può aiutarvi a ridurre le dimensioni dei pacchetti di distribuzione, separare la logica delle funzioni principali dalle dipendenze e consentire di condividere le dipendenze tra più funzioni. Per informazioni sui livelli, consulta i [layer AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html) nella *AWS Lambda Developer* Guide.

## Come creare un layer Lambda in AWS SAM
<a name="w2aac18c23c19c34b7"></a>

**Nota**  
Prima di poter creare un layer Lambda, devi prima scrivere un layer Lambda nel tuo modello. AWS SAM Per informazioni ed esempi su come eseguire questa operazione, consulta. [Aumenta l'efficienza utilizzando i livelli Lambda con AWS SAM](serverless-sam-cli-layers.md)

Per creare un layer personalizzato, dichiaratelo nel vostro file modello AWS Serverless Application Model (AWS SAM) e includete una sezione dedicata agli attributi `Metadata` delle risorse con una `BuildMethod` voce. I valori validi per `BuildMethod` sono identificatori per un [AWS Lambda runtime](https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html), o. `makefile` Includi una `BuildArchitecture` voce per specificare le architetture del set di istruzioni supportate dal livello. I valori validi per `BuildArchitecture` le architetture dei [set di istruzioni Lambda](https://docs.aws.amazon.com/lambda/latest/dg/foundation-arch.html).

Se lo specificate`makefile`, fornite il makefile personalizzato, in cui dichiarate un obiettivo di compilazione del modulo `build-layer-logical-id` che contiene i comandi di compilazione per il livello. Il makefile è responsabile della compilazione del layer, se necessario, e della copia degli artefatti di compilazione nella posizione corretta richiesta per le fasi successive del flusso di lavoro. La posizione del makefile è specificata dalla `ContentUri` proprietà della risorsa del livello e deve essere denominata. `Makefile`

**Nota**  
Quando create un layer personalizzato, la ricerca del codice del layer AWS Lambda dipende dalle variabili di ambiente. I runtime Lambda includono i percorsi nella `/opt` directory in cui viene copiato il codice del layer. La struttura delle cartelle degli artefatti di compilazione del progetto deve corrispondere alla struttura delle cartelle prevista per il runtime in modo da poter trovare il codice del layer personalizzato.  
Ad esempio, per Python puoi inserire il codice nella `python/` sottodirectory. Per NodeJS, puoi inserire il codice nella sottodirectory. `nodejs/node_modules/`  
*Per ulteriori informazioni, consulta [Inclusione delle dipendenze delle librerie in un livello nella Guida](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html#configuration-layers-path) per gli sviluppatori.AWS Lambda *

Di seguito è riportato un esempio di sezione relativa agli attributi `Metadata` delle risorse.

```
    Metadata:
      BuildMethod: python3.12
      BuildArchitecture: arm64
```

**Nota**  
Se non includi la sezione degli attributi `Metadata` delle risorse, AWS SAM non crea il layer. Copia invece gli artefatti di compilazione dalla posizione specificata nella `CodeUri` proprietà della risorsa del livello. Per ulteriori informazioni, vedete la [ContentUri](sam-resource-layerversion.md#sam-layerversion-contenturi)proprietà del tipo di `AWS::Serverless::LayerVersion` risorsa.

Quando includete la sezione degli attributi `Metadata` delle risorse, potete usare il `sam build` comando per creare il livello, sia come oggetto indipendente che come dipendenza di una AWS Lambda funzione.
+ ****Come oggetto indipendente.**** Potresti voler creare solo l'oggetto layer, ad esempio quando stai testando localmente una modifica al codice del layer e non hai bisogno di creare l'intera applicazione. Per creare il livello in modo indipendente, specificate la risorsa del livello con il `sam build layer-logical-id` comando.
+ **Come dipendenza di una funzione Lambda.** Quando includi l'ID logico di un livello nella `Layers` proprietà di una funzione Lambda nello stesso file AWS SAM modello, il livello è una dipendenza di quella funzione Lambda. Quando quel livello include anche una sezione di attributi di `Metadata` risorsa con una `BuildMethod` voce, si crea il livello creando l'intera applicazione con il `sam build` comando o specificando la risorsa della funzione con il comando. `sam build function-logical-id`

## Esempi
<a name="building-applications-examples"></a>

### Esempio di modello 1: crea un livello rispetto all'ambiente di runtime Python 3.12
<a name="building-applications-examples-python"></a>

Il seguente AWS SAM modello di esempio crea un livello rispetto all'ambiente di runtime Python 3.12.

```
Resources:
  MyLayer:
    Type: AWS::Serverless::LayerVersion
    Properties:
      ContentUri: my_layer
      CompatibleRuntimes:
        - python3.12
    Metadata:
      BuildMethod: python3.12   # Required to have AWS SAM build this layer
```

### Esempio di modello 2: crea un livello utilizzando un makefile personalizzato
<a name="building-applications-examples-makefile"></a>

Il seguente AWS SAM modello di esempio utilizza un modello personalizzato `makefile` per creare il layer.

```
Resources:
  MyLayer:
    Type: AWS::Serverless::LayerVersion
    Properties:
      ContentUri: my_layer
      CompatibleRuntimes:
        - python3.12
    Metadata:
      BuildMethod: makefile
```

Quanto segue `makefile` contiene l'obiettivo di compilazione e i comandi che verranno eseguiti. Nota che la `ContentUri` proprietà è impostata su`my_layer`, quindi il makefile deve trovarsi nella radice della `my_layer` sottodirectory e il nome del file deve essere. `Makefile` Nota anche che gli artefatti di compilazione vengono copiati nella `python/` sottodirectory in modo che sia AWS Lambda possibile trovare il codice del livello.

```
build-MyLayer:
  mkdir -p "$(ARTIFACTS_DIR)/python"
  cp *.py "$(ARTIFACTS_DIR)/python"
  python -m pip install -r requirements.txt -t "$(ARTIFACTS_DIR)/python"
```

**Nota**  
Quando `makefile` viene chiamato, viene attivato il target appropriato e gli artefatti devono essere copiati nella variabile ambientale esposta. `$ARTIFACTS_DIR` [Per ulteriori informazioni, fare riferimento a in. aws-lambda-builders GitHub](https://github.com/aws/aws-lambda-builders/blob/develop/aws_lambda_builders/workflows/custom_make/DESIGN.md)

### Esempi di comandi sam build
<a name="building-applications-examples-commands"></a>

I seguenti `sam build` comandi creano livelli che includono le sezioni degli attributi `Metadata` delle risorse.

```
# Build the 'layer-logical-id' resource independently
$ sam build layer-logical-id
            
# Build the 'function-logical-id' resource and layers that this function depends on
$ sam build function-logical-id

# Build the entire application, including the layers that any function depends on
$ sam build
```