Crea un pacchetto per il contenuto del livello Crea il livello in Lambda.Aggiungi il livello alla tua funzione.app di esempio

Utilizzo dei livelli per le funzioni Lambda in Python

Usa i livelli Lambda per impacchettare codice e dipendenze che desideri riutilizzare in più funzioni. I livelli di solito contengono dipendenze dalla libreria, un runtime personalizzato o file di configurazione. La creazione di un livello prevede tre passaggi generali:

Crea un pacchetto per il contenuto del livello. Ciò significa creare un archivio di file con estensione .zip che contiene le dipendenze che desideri utilizzare nelle funzioni.
Crea il livello in Lambda.
Aggiungi il livello alle tue funzioni.

Argomenti

Crea un pacchetto per il contenuto del livello
Crea il livello in Lambda.
Aggiungi il livello alla tua funzione.
app di esempio

Crea un pacchetto per il contenuto del livello

Per creare un livello, raggruppa i pacchetti in un archivio di file con estensione zip che soddisfi i requisiti riportati di seguito.

Costruisci il livello utilizzando la stessa versione di Python che intendi utilizzare per la funzione Lambda. Ad esempio, se crei il tuo layer usando Python 3.13, usa il runtime Python 3.13 per la tua funzione.
Il file.zip deve includere una python directory a livello root.
I pacchetti del livello devono essere compatibili con Linux. Le funzioni Lambda vengono eseguite su Amazon Linux.

È possibile creare livelli che contengono librerie Python di terze parti installate con pip (come requests opandas) o moduli e pacchetti Python personalizzati.

Per creare un livello utilizzando pacchetti pip

Scegliete uno dei seguenti metodi per installare pip i pacchetti nella directory di primo livello richiesta ()python/:
pip install
Per pacchetti Python puri (come requests o boto3):
```
pip install requests -t python/
```
Alcuni pacchetti Python, come NumPy e Pandas, includono componenti C compilati. Se state creando un layer con questi pacchetti su macOS o Windows, potreste aver bisogno di usare questo comando per installare una ruota compatibile con Linux:
```
pip install numpy --platform manylinux2014_x86_64 --only-binary=:all: -t python/
```
Per ulteriori informazioni sull'utilizzo di pacchetti Python che contengono componenti compilati, consulta. Creazione di un pacchetto di implementazione .zip con librerie native
requirements.txt
L'utilizzo di un requirements.txt file consente di gestire le versioni dei pacchetti e garantire installazioni coerenti.
Esempio requirements.txt
requests==2.31.0 boto3==1.37.34 numpy==1.26.4
Se il tuo requirements.txt file include solo pacchetti Python puri (come requests o boto3):
```
pip install -r requirements.txt -t python/
```
Alcuni pacchetti Python, come NumPy e Pandas, includono componenti C compilati. Se state creando un layer con questi pacchetti su macOS o Windows, potreste aver bisogno di usare questo comando per installare una ruota compatibile con Linux:
```
pip install -r requirements.txt --platform manylinux2014_x86_64 --only-binary=:all: -t python/
```
Per ulteriori informazioni sull'utilizzo di pacchetti Python che contengono componenti compilati, consulta. Creazione di un pacchetto di implementazione .zip con librerie native
Il contenuto della directory python
Linux/macOS
```
zip -r layer.zip python/
```
PowerShell
```
Compress-Archive -Path .\python -DestinationPath .\layer.zip
```
L'aspetto della struttura di directory dovrebbe essere simile al seguente:
```
python/              # Required top-level directory
└── requests/
└── boto3/
└── numpy/
└── (dependencies of the other packages)
```
Nota
Se usi un ambiente virtuale Python (venv) per installare i pacchetti, la struttura delle cartelle sarà diversa (ad esempio,). python/lib/python3.x/site-packages Finché il file.zip include la python directory a livello principale, Lambda può localizzare e importare i pacchetti.

Per creare un livello utilizzando il tuo codice

Crea la directory di primo livello richiesta per il tuo layer:
```
mkdir python
```

Crea i tuoi moduli Python nella python directory. Il seguente modulo di esempio convalida gli ordini confermando che contengono le informazioni richieste.

Esempio modulo personalizzato: validator.py


import json

def validate_order(order_data):
    """Validates an order and returns formatted data."""
    required_fields = ['product_id', 'quantity']
    
    # Check required fields
    missing_fields = [field for field in required_fields if field not in order_data]
    if missing_fields:
        raise ValueError(f"Missing required fields: {', '.join(missing_fields)}")
    
    # Validate quantity
    quantity = order_data['quantity']
    if not isinstance(quantity, int) or quantity < 1:
        raise ValueError("Quantity must be a positive integer")
    
    # Format and return the validated data
    return {
        'product_id': str(order_data['product_id']),
        'quantity': quantity,
        'shipping_priority': order_data.get('priority', 'standard')
    }

def format_response(status_code, body):
    """Formats the API response."""
    return {
        'statusCode': status_code,
        'body': json.dumps(body)
    }

Il contenuto della directory python

L'aspetto della struttura di directory dovrebbe essere simile al seguente:

python/     # Required top-level directory
└── validator.py

Nella tua funzione, importa e usa i moduli come faresti con qualsiasi pacchetto Python. Esempio:


from validator import validate_order, format_response
import json

def lambda_handler(event, context):
    try:
        # Parse the order data from the event body
        order_data = json.loads(event.get('body', '{}'))
        
        # Validate and format the order
        validated_order = validate_order(order_data)
        
        return format_response(200, {
            'message': 'Order validated successfully',
            'order': validated_order
        })
    except ValueError as e:
        return format_response(400, {
            'error': str(e)
        })
    except Exception as e:
        return format_response(500, {
            'error': 'Internal server error'
        })

È possibile utilizzare i seguenti dati evento per invocare la funzione:


{
    "body": "{\"product_id\": \"ABC123\", \"quantity\": 2, \"priority\": \"express\"}"
}

Risposta prevista:


{
  "statusCode": 200,
  "body": "{\"message\": \"Order validated successfully\", \"order\": {\"product_id\": \"ABC123\", \"quantity\": 2, \"shipping_priority\": \"express\"}}"
}

Crea il livello in Lambda.

È possibile creare la funzione Lambda mediante la AWS CLI o la console Lambda.

Aggiungi il livello alla tua funzione.

app di esempio

Per altri esempi di utilizzo dei layer Lambda, consulta l'applicazione di esempio layer-python nel repository GitHub della Developer AWS Lambda Guide. Questa applicazione include due livelli che contengono librerie Python. Dopo aver creato i livelli, puoi implementare e richiamare le funzioni corrispondenti per confermare che i livelli funzionino come previsto.

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Implementazione di immagini di container

Contesto