Crea un'app di elaborazione file senza server - AWS Lambda
PrerequisitiScaricamento dei file dell'app di esempioDistribuzione dell'appTest dell'appPassaggi successivi

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

Crea un'app di elaborazione file senza server

Uno dei casi d'uso più comuni di Lambda è l'esecuzione di attività di elaborazione dei file. Ad esempio, è possibile utilizzare una funzione Lambda per creare automaticamente PDF file da HTML file o immagini o per creare miniature quando un utente carica un'immagine.

In questo esempio, crei un'app che crittografa automaticamente PDF i file quando vengono caricati su un bucket Amazon Simple Storage Service (Amazon S3). Per implementare questa app, crei le seguenti risorse:

  • Un bucket S3 in cui gli utenti possono caricare file PDF

  • Una funzione Lambda in Python che legge il file caricato e ne crea una versione crittografata e protetta da password

  • Un secondo bucket S3 per Lambda in cui salvare il file crittografato

Puoi anche creare una policy AWS Identity and Access Management (IAM) per autorizzare la funzione Lambda a eseguire operazioni di lettura e scrittura sui bucket S3.

Diagramma che mostra il flusso di dati tra un bucket S3, una funzione Lambda e un altro bucket S3
Suggerimento

Se non conosci Lambda, ti consigliamo di seguire il tutorial Crea la tua prima funzione Lambda prima di creare questa app di esempio.

Puoi distribuire l'app manualmente creando e configurando risorse con AWS Management Console o il AWS Command Line Interface ().AWS CLI Puoi anche distribuire l'app utilizzando (). AWS Serverless Application Model AWS SAM AWS SAM è uno strumento Infrastructure as Code (IaC). Con IaC, non si creano risorse manualmente, ma le si definisce in codice e poi le si distribuisce automaticamente.

Se vuoi saperne di più sull'uso di Lambda con IAc prima di distribuire questa app di esempio, consulta. Utilizzo di Lambda con l'infrastructure as code (IaC)

Prerequisiti

Prima di creare l'app di esempio, assicurati di aver installato gli strumenti da riga di comando richiesti.

  • AWS CLI

    Puoi distribuire manualmente le risorse per la tua app utilizzando AWS Management Console o. AWS CLI Per utilizzare ilCLI, installalo seguendo le istruzioni di installazione nella Guida per l'AWS Command Line Interface utente.

  • AWS SAM CLI

    Se desideri distribuire l'app di esempio utilizzando AWS SAM, devi installare sia il che AWS CLI il AWS SAM CLI. Per installare AWS SAM CLI, segui le istruzioni di installazione nella Guida per l'AWS SAM utente.

  • modulo pytest

    Dopo aver distribuito la tua app, puoi testarla utilizzando uno script di test Python automatico che forniamo. Per utilizzare questo script, installa il pytest pacchetto nel tuo ambiente di sviluppo locale eseguendo il seguente comando:

    pip install pytest

Per distribuire l'app utilizzando AWS SAM, Docker deve essere installato anche sulla macchina di compilazione.

Scaricamento dei file dell'app di esempio

Per creare e testare l'app di esempio, create i seguenti file nella directory del progetto:

  • lambda_function.py- il codice della funzione Python per la funzione Lambda che esegue la crittografia dei file

  • requirements.txt- un file manifest che definisce le dipendenze richieste dal codice della funzione Python

  • template.yaml- un AWS SAM modello che puoi usare per distribuire l'app

  • test_pdf_encrypt.py- uno script di test che puoi utilizzare per testare automaticamente l'applicazione

  • pytest.ini- un file di configurazione per lo script di test

Espandi le seguenti sezioni per visualizzare il codice e per saperne di più sul ruolo di ciascun file nella creazione e nel test dell'app. Per creare i file sul tuo computer locale, copia e incolla il codice seguente o scarica i file dal aws-lambda-developer-guide GitHub repository.

Copia e incolla il seguente codice in un file denominatolambda_function.py.

from pypdf import PdfReader, PdfWriter
import uuid
import os
from urllib.parse import unquote_plus
import boto3

# Create the S3 client to download and upload objects from S3
s3_client = boto3.client('s3')

def lambda_handler(event, context):
    # Iterate over the S3 event object and get the key for all uploaded files
    for record in event['Records']:
        bucket = record['s3']['bucket']['name']
        key = unquote_plus(record['s3']['object']['key']) # Decode the S3 object key to remove any URL-encoded characters
        download_path = f'/tmp/{uuid.uuid4()}.pdf' # Create a path in the Lambda tmp directory to save the file to 
        upload_path = f'/tmp/converted-{uuid.uuid4()}.pdf' # Create another path to save the encrypted file to
        
        # If the file is a PDF, encrypt it and upload it to the destination S3 bucket
        if key.lower().endswith('.pdf'):
            s3_client.download_file(bucket, key, download_path)
            encrypt_pdf(download_path, upload_path)
            encrypted_key = add_encrypted_suffix(key)
            s3_client.upload_file(upload_path, f'{bucket}-encrypted', encrypted_key)

# Define the function to encrypt the PDF file with a password
def encrypt_pdf(file_path, encrypted_file_path):
    reader = PdfReader(file_path)
    writer = PdfWriter()
    
    for page in reader.pages:
        writer.add_page(page)

    # Add a password to the new PDF
    writer.encrypt("my-secret-password")

    # Save the new PDF to a file
    with open(encrypted_file_path, "wb") as file:
        writer.write(file)

# Define a function to add a suffix to the original filename after encryption
def add_encrypted_suffix(original_key):
    filename, extension = original_key.rsplit('.', 1)
    return f'{filename}_encrypted.{extension}'
Nota

In questo codice di esempio, una password per il file crittografato (my-secret-password) è inserita nel codice della funzione. In un'applicazione di produzione, non includete informazioni sensibili come le password nel codice della funzione. Utilizzatelo AWS Secrets Manager per archiviare in modo sicuro i parametri sensibili.

Il codice della funzione python contiene tre funzioni: la funzione di gestione che Lambda esegue quando la funzione viene richiamata e due funzioni separate denominate add_encrypted_suffix e encrypt_pdf che il gestore chiama per eseguire la crittografia. PDF

Quando la funzione viene richiamata da Amazon S3, Lambda passa JSON un argomento di evento formattato alla funzione che contiene dettagli sull'evento che ha causato la chiamata. In questo caso, le informazioni includono il nome del bucket S3 e le chiavi oggetto per i file caricati. Per ulteriori informazioni sul formato dell'oggetto evento per Amazon S3, consulta. Elabora le notifiche degli eventi di Amazon S3 con Lambda

La funzione utilizza quindi il AWS SDK for Python (Boto3) per scaricare i PDF file specificati nell'oggetto evento nella relativa directory di archiviazione temporanea locale, prima di crittografarli utilizzando la pypdflibreria.

Infine, la funzione utilizza Boto3 SDK per archiviare il file crittografato nel bucket di destinazione S3.

Copia e incolla il codice seguente in un file denominatorequirements.txt.

boto3
pypdf

Per questo esempio, il codice della funzione ha solo due dipendenze che non fanno parte della libreria Python standard: SDK for Python (Boto3) e pypdf il pacchetto utilizzato dalla funzione per eseguire la crittografia. PDF

Nota

Una versione di SDK for Python (Boto3) è inclusa come parte del runtime Lambda, quindi il codice potrebbe essere eseguito senza aggiungere Boto3 al pacchetto di distribuzione della funzione. Tuttavia, per mantenere il pieno controllo delle dipendenze della funzione ed evitare possibili problemi di disallineamento della versione, la migliore pratica per Python consiste nell'includere tutte le dipendenze delle funzioni nel pacchetto di distribuzione della funzione. Per ulteriori informazioni, consulta Dipendenze di runtime in Python.

Copia e incolla il seguente codice in un file denominatotemplate.yaml.

AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31

Resources:
  EncryptPDFFunction:
    Type: AWS::Serverless::Function
    Properties:
      FunctionName: EncryptPDF
      Architectures: [x86_64]
      CodeUri: ./
      Handler: lambda_function.lambda_handler
      Runtime: python3.12
      Timeout: 15
      MemorySize: 256
      LoggingConfig:
        LogFormat: JSON
      Policies:
        - AmazonS3FullAccess
      Events:
        S3Event:
          Type: S3
          Properties:
            Bucket: !Ref PDFSourceBucket
            Events: s3:ObjectCreated:*

  PDFSourceBucket:
    Type: AWS::S3::Bucket
    Properties:
      BucketName: EXAMPLE-BUCKET

  EncryptedPDFBucket:
    Type: AWS::S3::Bucket
    Properties:
      BucketName: EXAMPLE-BUCKET-encrypted

Il AWS SAM modello definisce le risorse che crei per la tua app. In questo esempio, il modello definisce una funzione Lambda utilizzando il AWS::Serverless::Function tipo e due bucket S3 che utilizzano il tipo. AWS::S3::Bucket I nomi dei bucket specificati nel modello sono segnaposto. Prima di distribuire l'app utilizzando AWS SAM, devi modificare il modello per rinominare i bucket con nomi univoci globali che soddisfino le regole di denominazione dei bucket S3. Questo passaggio viene spiegato più avanti. Distribuisci le risorse utilizzando AWS SAM

La definizione della risorsa della funzione Lambda configura un trigger per la funzione utilizzando la S3Event proprietà event. Questo trigger fa sì che la funzione venga richiamata ogni volta che viene creato un oggetto nel bucket di origine.

La definizione della funzione specifica anche una politica AWS Identity and Access Management (IAM) da allegare al ruolo di esecuzione della funzione. La policy AWS gestita AmazonS3FullAccess fornisce alla tua funzione le autorizzazioni necessarie per leggere e scrivere oggetti su Amazon S3.

Copia e incolla il codice seguente in un file denominatotest_pdf_encrypt.py.

import boto3
import json
import pytest
import time
import os

@pytest.fixture
def lambda_client():
    return boto3.client('lambda')
    
@pytest.fixture
def s3_client():
    return boto3.client('s3')

@pytest.fixture
def logs_client():
    return boto3.client('logs')

@pytest.fixture(scope='session')
def cleanup():
    # Create a new S3 client for cleanup
    s3_client = boto3.client('s3')

    yield
    # Cleanup code will be executed after all tests have finished

    # Delete test.pdf from the source bucket
    source_bucket = 'EXAMPLE-BUCKET'
    source_file_key = 'test.pdf'
    s3_client.delete_object(Bucket=source_bucket, Key=source_file_key)
    print(f"\nDeleted {source_file_key} from {source_bucket}")

    # Delete test_encrypted.pdf from the destination bucket
    destination_bucket = 'EXAMPLE-BUCKET-encrypted'
    destination_file_key = 'test_encrypted.pdf'
    s3_client.delete_object(Bucket=destination_bucket, Key=destination_file_key)
    print(f"Deleted {destination_file_key} from {destination_bucket}")
        

@pytest.mark.order(1)
def test_source_bucket_available(s3_client):
    s3_bucket_name = 'EXAMPLE-BUCKET'
    file_name = 'test.pdf'
    file_path = os.path.join(os.path.dirname(__file__), file_name)

    file_uploaded = False
    try:
        s3_client.upload_file(file_path, s3_bucket_name, file_name)
        file_uploaded = True
    except:
        print("Error: couldn't upload file")

    assert file_uploaded, "Could not upload file to S3 bucket"

    

@pytest.mark.order(2)
def test_lambda_invoked(logs_client):

    # Wait for a few seconds to make sure the logs are available
    time.sleep(5)

    # Get the latest log stream for the specified log group
    log_streams = logs_client.describe_log_streams(
        logGroupName='/aws/lambda/EncryptPDF',
        orderBy='LastEventTime',
        descending=True,
        limit=1
    )

    latest_log_stream_name = log_streams['logStreams'][0]['logStreamName']

    # Retrieve the log events from the latest log stream
    log_events = logs_client.get_log_events(
        logGroupName='/aws/lambda/EncryptPDF',
        logStreamName=latest_log_stream_name
    )

    success_found = False
    for event in log_events['events']:
        message = json.loads(event['message'])
        status = message.get('record', {}).get('status')
        if status == 'success':
            success_found = True
            break

    assert success_found, "Lambda function execution did not report 'success' status in logs."

@pytest.mark.order(3)
def test_encrypted_file_in_bucket(s3_client):
    # Specify the destination S3 bucket and the expected converted file key
    destination_bucket = 'EXAMPLE-BUCKET-encrypted'
    converted_file_key = 'test_encrypted.pdf'

    try:
        # Attempt to retrieve the metadata of the converted file from the destination S3 bucket
        s3_client.head_object(Bucket=destination_bucket, Key=converted_file_key)
    except s3_client.exceptions.ClientError as e:
        # If the file is not found, the test will fail
        pytest.fail(f"Converted file '{converted_file_key}' not found in the destination bucket: {str(e)}")

def test_cleanup(cleanup):
    # This test uses the cleanup fixture and will be executed last
    pass

Lo script di test automatico esegue tre funzioni di test per confermare il corretto funzionamento dell'app:

  • Il test test_source_bucket_available conferma che il bucket di origine è stato creato correttamente caricando un PDF file di test nel bucket.

  • Il test test_lambda_invoked interroga il flusso di log di CloudWatch Logs più recente della funzione per confermare che quando hai caricato il file di test, la funzione Lambda è stata eseguita e ha segnalato il successo.

  • Il test test_encrypted_file_in_bucket conferma che il bucket di destinazione contiene il file crittografato. test_encrypted.pdf

Dopo l'esecuzione di tutti questi test, lo script esegue un ulteriore passaggio di pulizia per eliminare i test_encrypted.pdf file test.pdf and dai bucket di origine e di destinazione.

Come nel AWS SAM modello, i nomi dei bucket specificati in questo file sono segnaposto. Prima di eseguire il test, devi modificare questo file con i veri nomi dei bucket dell'app. Questo passaggio è spiegato più avanti in Test dell'app con lo script automatico

Copia e incolla il codice seguente in un file denominatopytest.ini.

[pytest]
markers =
    order: specify test execution order

Ciò è necessario per specificare l'ordine in cui vengono eseguiti i test nello test_pdf_encrypt.py script.

Distribuzione dell'app

È possibile creare e distribuire le risorse per questa app di esempio manualmente o utilizzando. AWS SAM In un ambiente di produzione, si consiglia di utilizzare uno strumento IaC come quello AWS SAM per distribuire in modo rapido e ripetibile intere applicazioni serverless senza utilizzare processi manuali.

Per questo esempio, segui la console o AWS CLI le istruzioni per imparare a configurare ogni AWS risorsa separatamente, oppure passa subito Distribuisci le risorse utilizzando AWS SAM alla distribuzione rapida dell'app utilizzando alcuni comandi. CLI

Distribuisci le risorse manualmente

Per distribuire l'app manualmente, procedi nel seguente modo:

  • Crea bucket S3 di origine e destinazione

  • Crea una funzione Lambda che crittografa un PDF file e salva la versione crittografata in un bucket S3

  • Configura un trigger Lambda che richiami la tua funzione quando gli oggetti vengono caricati nel bucket di origine

Segui le istruzioni riportate nei paragrafi seguenti per creare e configurare le tue risorse.

Crea due bucket S3

Per prima cosa crea due bucket S3. Il primo bucket è il bucket di origine in cui caricherai i tuoi file. PDF Il secondo bucket viene utilizzato da Lambda per salvare il file crittografato quando si richiama la funzione.

Console
Per creare i bucket S3 (console)

  1. Nella console Amazon S3, apri la pagina Bucket.

  2. Scegliere Create bucket (Crea bucket).

  3. In General configuration (Configurazione generale), eseguire le operazioni seguenti:

    1. Per Nome del bucket, inserisci un nome univoco globale che soddisfi le regole di denominazione dei bucket di Amazon S3. I nomi dei bucket possono contenere solo lettere minuscole, numeri, punti (.) e trattini (-).

    2. Per Regione AWS, scegli la Regione AWS più vicina alla tua posizione geografica. Più avanti nel processo di distribuzione, devi creare la tua funzione Lambda nella stessa Regione AWS, quindi prendi nota della regione che hai scelto.

  4. Lascia tutte le altre opzioni impostate sui valori predefiniti e scegli Crea bucket.

  5. Ripeti i passaggi da 1 a 4 per creare il bucket di destinazione. Per Nome del bucket, inserisci SOURCEBUCKET-encrypted, dove SOURCEBUCKET è il nome del bucket di origine che hai appena creato.

AWS CLI
Per creare i bucket S3 ()AWS CLI

  1. Esegui il CLI comando seguente per creare il tuo bucket sorgente. Il nome che scegli per il bucket deve essere univoco a livello globale e seguire le regole di denominazione dei bucket di Amazon S3. I nomi possono contenere solo lettere minuscole, numeri, punti (.) e trattini (-). Per region e LocationConstraint, scegli la Regione AWS più vicina alla tua posizione geografica.

    aws s3api create-bucket --bucket SOURCEBUCKET --region us-west-2 \
--create-bucket-configuration LocationConstraint=us-west-2

    Più avanti nel tutorial, devi creare la tua funzione Lambda nello Regione AWS stesso bucket di origine, quindi prendi nota della regione che hai scelto.

  2. Esegui il comando sotto riportato per creare il bucket di destinazione. Per il nome del bucket, devi usare SOURCEBUCKET-encrypted, dove SOURCEBUCKET è il nome del bucket di origine che hai creato nel passaggio 1. Per region eLocationConstraint, scegli lo stesso Regione AWS che hai usato per creare il bucket sorgente.

    aws s3api create-bucket --bucket SOURCEBUCKET-encrypted --region us-west-2 \
--create-bucket-configuration LocationConstraint=us-west-2

Crea un ruolo di esecuzione (AWS CLI solo)

Un ruolo di esecuzione è un IAM ruolo che concede a una funzione Lambda l'autorizzazione all' Servizi AWS accesso e alle risorse. Quando crei una funzione utilizzando la console Lambda, Lambda crea automaticamente un ruolo di esecuzione. Devi creare un ruolo manualmente solo se scegli di distribuire l'app utilizzando. AWS CLI Per consentire alla tua funzione di accedere in lettura e scrittura ad Amazon S3, alleghi la policy AWS gestita. AmazonS3FullAccess

Console

Questo passaggio è necessario solo se scegli di distribuire la tua app utilizzando. AWS CLI

AWS CLI
Per creare un ruolo di esecuzione e allegare la policy AmazonS3FullAccess gestita ()AWS CLI

  1. Salva quanto segue JSON in un file denominatotrust-policy.json. Questa politica di fiducia consente a Lambda di utilizzare le autorizzazioni del ruolo concedendo al servizio principale l'lambda.amazonaws.com.rproxy.goskope.comautorizzazione a chiamare l'azione AWS Security Token Service ()AWS STS. AssumeRole

    {
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "Service": "lambda.amazonaws.com"
      },
      "Action": "sts:AssumeRole"
    }
  ]
}

  2. Dalla directory in cui hai salvato il documento sulla politica di JSON fiducia, esegui il CLI comando seguente per creare il ruolo di esecuzione.

    aws iam create-role --role-name LambdaS3Role --assume-role-policy-document file://trust-policy.json

  3. Per allegare la politica AmazonS3FullAccess gestita, esegui il CLI comando seguente.

    aws iam attach-role-policy --role-name LambdaS3Role --policy-arn arn:aws:iam::aws:policy/AmazonS3FullAccess

Creazione del pacchetto di implementazione della funzione

Per creare la funzione, occorre creare un pacchetto di implementazione contenente la funzione e le rispettive dipendenze. Per questa applicazione, il codice della funzione utilizza una libreria separata per la PDF crittografia.

Per creare il pacchetto di implementazione

  1. Passa alla directory del progetto contenente i requirements.txt file lambda_function.py e che hai creato o scaricato GitHub in precedenza e crea una nuova directory denominatapackage.

  2. Installa le dipendenze specificate nel requirements.txt file nella tua package directory eseguendo il comando seguente.

    pip install -r requirements.txt --target ./package/

  3. Crea un file.zip contenente il codice dell'applicazione e le sue dipendenze. Su Linux o MacOS, esegui i comandi riportati di seguito dall'interfaccia della linea di comando.

    cd package
zip -r ../lambda_function.zip .
cd ..
zip lambda_function.zip lambda_function.py

    Su Windows, usa il tuo strumento di compressione preferito per creare il file lambda_function.zip. Assicurati che il tuo file lambda_function.py e le cartelle contenenti le tue dipendenze si trovino tutti nella directory principale del file .zip.

Puoi creare il tuo pacchetto di implementazione anche utilizzando un ambiente virtuale Python. Consulta la sezione Utilizzo di archivi di file .zip per le funzioni Lambda in Python

Creazione della funzione Lambda

Ora usi il pacchetto di distribuzione creato nel passaggio precedente per distribuire la tua funzione Lambda.

Console
Creazione della funzione (console)

Per creare la tua funzione Lambda utilizzando la console, devi prima creare una funzione di base contenente del codice "Hello world". Quindi sostituisci questo codice con il tuo codice di funzione caricando il file the.zip creato nel passaggio precedente.

Per garantire che la funzione non scada durante la crittografia di PDF file di grandi dimensioni, configurate le impostazioni di memoria e timeout della funzione. È inoltre possibile impostare il formato di registro della funzione su. JSON La configurazione dei log JSON formattati è necessaria quando si utilizza lo script di test fornito in modo che possa leggere lo stato di chiamata della funzione da CloudWatch Logs per confermare l'avvenuta chiamata.

  1. Aprire la pagina Funzioni della console Lambda.

  2. Assicurati di lavorare nello stesso bucket in cui hai creato il bucket S3. Regione AWS Puoi modificare la regione utilizzando l'elenco a discesa nella parte superiore dello schermo.

    Immagine che mostra il menu a discesa delle regioni nella console Lambda

  3. Selezionare Create function (Crea funzione).

  4. Scegli Author from scratch (Crea da zero).

  5. In Basic information (Informazioni di base) eseguire queste operazioni:

    1. Nel campo Function name (Nome funzione), immettere EncryptPDF.

    2. Per Runtime scegli Python 3.12.

    3. In Architecture (Architettura), scegli x86_64.

  6. Scegli Crea funzione.

Caricamento del codice della funzione (console)

  1. Nel riquadro Origine del codice, scegli Carica da.

  2. Scegli File .zip.

  3. Scegli Carica.

  4. Nel selettore di file, seleziona il tuo file .zip e scegli Apri.

  5. Seleziona Salva.

Per configurare la funzione memory e timeout (console)

  1. Seleziona la scheda Configurazione per la tua funzione.

  2. Nel riquadro di configurazione generale, scegli Modifica.

  3. Imposta la memoria su 256 MB e il timeout su 15 secondi.

  4. Seleziona Salva.

Per configurare il formato del registro (console)

  1. Seleziona la scheda Configurazione per la tua funzione.

  2. Seleziona Strumenti operativi e di monitoraggio.

  3. Nel riquadro Configurazione della registrazione, scegli Modifica.

  4. Per la configurazione della registrazione, selezionare JSON.

  5. Seleziona Salva.

AWS CLI
Creazione della funzione (AWS CLI)

  • Esegui il comando seguente dalla directory contenente il tuo lambda_function.zip file. Per il region parametro, sostituiscilo us-west-2 con la regione in cui hai creato i bucket S3.

    aws lambda create-function --function-name EncryptPDF \
--zip-file fileb://lambda_function.zip --handler lambda_function.lambda_handler \
--runtime python3.12 --timeout 15 --memory-size 256 \
--role arn:aws:iam::123456789012:role/LambdaS3Role --region us-west-2 \
--logging-config LogFormat=JSON

Configura un trigger Amazon S3 per richiamare la funzione

Affinché la funzione Lambda venga eseguita quando carichi un file nel bucket di origine, devi configurare un trigger per la tua funzione. È possibile configurare il trigger Amazon S3 utilizzando la console Lambda o la AWS CLI.

Importante

Questa procedura configura il bucket S3 per richiamare la funzione ogni volta che un oggetto viene creato nel bucket. Assicurati di configurare questa opzione solo sul bucket di origine. Se la tua funzione Lambda crea oggetti nello stesso bucket che la richiama, la tua funzione può essere richiamata continuamente in un ciclo ricorsivo (loop). Ciò può comportare la fatturazione di addebiti imprevisti al tuo. Account AWS

Console
Configurazione del trigger Amazon S3 (console)

  1. Apri la pagina Funzioni della console Lambda e scegli la tua funzione (EncryptPDF).

  2. Selezionare Add trigger (Aggiungi trigger).

  3. Seleziona S3.

  4. In Bucket, seleziona il tuo bucket di origine.

  5. In Tipi di eventi, seleziona Tutti gli eventi di creazione di oggetti.

  6. In Invocazione ricorsiva, seleziona la casella di controllo per confermare che non è consigliabile utilizzare lo stesso bucket S3 per input e output. Per maggiori informazioni sui modelli di invocazione ricorsivi in Lambda, consulta Schemi ricorsivi che causano loop indeterminati delle funzioni Lambda in Serverless Land.

  7. Scegli Aggiungi.

    Quando crei un trigger utilizzando la console Lambda, Lambda crea automaticamente una policy basata sulle risorse per concedere al servizio selezionato l'autorizzazione a richiamare la funzione.

AWS CLI
Configurazione del trigger Amazon S3 (AWS CLI)

  1. Affinché il tuo bucket di sorgenti Amazon S3 richiami la tua funzione quando aggiungi un file, devi prima configurare le autorizzazioni per la tua funzione utilizzando una policy basata sulle risorse. Una dichiarazione politica basata sulle risorse fornisce altre autorizzazioni per richiamare la tua funzione. Servizi AWS Per autorizzare Amazon S3 a richiamare la tua funzione, esegui il comando seguente. CLI Assicurati di sostituire il source-account parametro con il tuo Account AWS ID e di utilizzare il tuo nome di bucket sorgente.

    aws lambda add-permission --function-name EncryptPDF \
--principal s3.amazonaws.com --statement-id s3invoke --action "lambda:InvokeFunction" \
--source-arn arn:aws:s3:::SOURCEBUCKET \
--source-account 123456789012

    La policy che definisci con questo comando consente ad Amazon S3 di richiamare la tua funzione solo quando viene eseguita un'operazione sul tuo bucket di origine.

    Nota

    Sebbene i nomi dei bucket S3 siano unici a livello globale, quando si utilizzano politiche basate sulle risorse è consigliabile specificare che il bucket deve appartenere al proprio account. Questo perché se elimini un bucket, è possibile che un altro lo Account AWS crei con lo stesso Amazon Resource Name ()ARN.

  2. Salva quanto segue JSON in un file denominato. notification.json Se applicato al bucket di origine, questo JSON configura il bucket per inviare una notifica alla funzione Lambda ogni volta che viene aggiunto un nuovo oggetto. Sostituisci il Account AWS numero e Regione AWS nella funzione Lambda ARN con il tuo numero di account e la tua regione.

    {
"LambdaFunctionConfigurations": [
    {
      "Id": "EncryptPDFEventConfiguration",
      "LambdaFunctionArn": "arn:aws:lambda:us-west-2:123456789012:function:EncryptPDF",
      "Events": [ "s3:ObjectCreated:Put" ]
    }
  ]
}

  3. Esegui il CLI comando seguente per applicare le impostazioni di notifica nel JSON file che hai creato al tuo bucket di origine. Sostituisci SOURCEBUCKET con il nome del tuo bucket di origine.

    aws s3api put-bucket-notification-configuration --bucket SOURCEBUCKET \
--notification-configuration file://notification.json

    Per ulteriori informazioni sul put-bucket-notification-configuration comando e sull'notification-configurationopzione, consulta put-bucket-notification-configurationla sezione AWS CLICommand Reference.

Distribuisci le risorse utilizzando AWS SAM

Per distribuire l'app di esempio utilizzando il AWS SAM CLI, procedi nel seguente modo.

Assicurati di aver installato la versione più recente di CLI e che Docker sia installato sulla tua macchina di compilazione.

  1. Modifica il template.yaml file per specificare il nome dei tuoi bucket S3. I bucket S3 devono avere nomi univoci a livello globale che soddisfino le regole di denominazione dei bucket S3.

    Sostituisci il nome del bucket EXAMPLE-BUCKET con un nome a tua scelta composto da lettere minuscole, numeri, punti (.) e trattini (-). Per il bucket di destinazione, sostituisci EXAMPLE-BUCKET-encrypted con<source-bucket-name>-encrypted, dove <source-bucket> è il nome che hai scelto per il bucket di origine.

  2. Esegui il comando seguente dalla directory in cui hai salvato i tuoi file template.yamllambda_function.py, erequirements.txt.

    sam build --use-container

    Questo comando raccoglie gli artefatti di compilazione per l'applicazione e li colloca nel formato e nella posizione corretti per l'implementazione. Specificando l'--use-containeropzione si crea la funzione all'interno di un contenitore Docker simile a Lambda. Lo usiamo qui quindi non è necessario che Python 3.12 sia installato sul computer locale per far funzionare la build.

    Durante il processo di compilazione, AWS SAM cerca il codice della funzione Lambda nella posizione specificata con la CodeUri proprietà nel modello. In questo caso, abbiamo specificato la directory corrente come location (./).

    Se è presente un requirements.txt file, lo AWS SAM usa per raccogliere le dipendenze specificate. Per impostazione predefinita, AWS SAM crea un pacchetto di distribuzione.zip con il codice della funzione e le dipendenze. Puoi anche scegliere di distribuire la tua funzione come immagine contenitore utilizzando la proprietà. PackageType

  3. Per distribuire l'applicazione e creare le risorse Lambda e Amazon S3 specificate nel modello, AWS SAM esegui il comando seguente.

    sam deploy --guided

    L'uso del --guided flag significa che ti AWS SAM verranno mostrate le istruzioni per guidarti attraverso il processo di distribuzione. Per questa implementazione, accetta le opzioni predefinite premendo Invio.

Durante il processo di distribuzione, AWS SAM crea le seguenti risorse nel tuo: Account AWS

  • Una AWS CloudFormation pila denominata sam-app

  • Una funzione Lambda con il nome EncryptPDF

  • Due bucket S3 con i nomi che hai scelto quando hai modificato il file modello template.yaml AWS SAM

  • Un ruolo di IAM esecuzione per la tua funzione con il formato del nome sam-app-EncryptPDFFunctionRole-2qGaapHFWOQ8

Al AWS SAM termine della creazione delle risorse, dovresti visualizzare il seguente messaggio:

Successfully created/updated stack - sam-app in us-west-2

Test dell'app

Per testare la tua app, carichi un PDF file nel bucket di origine e confermi che Lambda crei una versione crittografata del file nel bucket di destinazione. In questo esempio, puoi testarlo manualmente utilizzando la console o il AWS CLI, oppure utilizzando lo script di test fornito.

Per le applicazioni di produzione, puoi utilizzare metodi e tecniche di test tradizionali, come il test unitario, per confermare il corretto funzionamento del codice di funzione Lambda. La migliore pratica consiste anche nell'eseguire test come quelli dello script di test fornito, che eseguono test di integrazione con risorse reali basate sul cloud. I test di integrazione nel cloud confermano che l'infrastruttura è stata implementata correttamente e che gli eventi fluiscono tra i diversi servizi come previsto. Per ulteriori informazioni, consulta Come testare funzioni e applicazioni serverless.

Test manuale dell'app

Puoi testare la tua funzione manualmente aggiungendo un PDF file al tuo bucket di origine Amazon S3. Quando aggiungi il file al bucket di origine, la funzione Lambda dovrebbe essere richiamata automaticamente e dovrebbe memorizzare una versione crittografata del file nel bucket di destinazione.

Console
Per testare l'app caricando un file (console)

  1. Per caricare un PDF file nel tuo bucket S3, procedi come segue:

    1. Apri la pagina Bucket della console Amazon S3 e scegli il bucket di origine.

    2. Scegli Carica.

    3. Scegli Aggiungi file e usa il selettore di file per scegliere il PDF file che desideri caricare.

    4. Seleziona Apri, quindi Carica.

  2. Verifica che Lambda abbia salvato una versione crittografata del PDF file nel bucket di destinazione effettuando le seguenti operazioni:

    1. Torna alla pagina Bucket della console Amazon S3 e scegli il bucket di destinazione.

    2. Nel riquadro Oggetti, ora dovresti vedere un file con il formato del nome filename_encrypted.pdf (filename.pdfdov'era il nome del file che hai caricato nel bucket di origine). Per scaricare il file crittografatoPDF, seleziona il file, quindi scegli Scarica.

    3. Conferma di poter aprire il file scaricato con la password con cui la funzione Lambda lo ha protetto ()my-secret-password.

AWS CLI
Per testare la tua app caricando un file ()AWS CLI

  1. Dalla directory contenente il PDF file che desideri caricare, esegui il CLI comando seguente. Sostituisci il parametro --bucket con il nome del bucket di origine. Per i --body parametri --key and, utilizzate il nome del file di test.

    aws s3api put-object --bucket SOURCEBUCKET --key test.pdf --body ./test.pdf

  2. Verifica che la tua funzione abbia creato una versione crittografata del file e l'abbia salvata nel bucket S3 di destinazione. Esegui il CLI comando seguente, sostituendolo SOURCEBUCKET-encrypted con il nome del tuo bucket di destinazione.

    aws s3api list-objects-v2 --bucket SOURCEBUCKET-encrypted

    Se la tua funzione viene eseguita correttamente, vedrai un output simile al seguente. Il bucket di destinazione deve contenere un file con il formato del nome<your_test_file>_encrypted.pdf, dove <your_test_file> è il nome del file che hai caricato.

    {
    "Contents": [
        {
            "Key": "test_encrypted.pdf",
            "LastModified": "2023-06-07T00:15:50+00:00",
            "ETag": "\"7781a43e765a8301713f533d70968a1e\"",
            "Size": 2763,
            "StorageClass": "STANDARD"
        }
    ]
}

  3. Per scaricare il file salvato da Lambda nel bucket di destinazione, esegui il comando seguente. CLI Sostituisci il --bucket parametro con il nome del bucket di destinazione. Per il --key parametro, usa il nome del file<your_test_file>_encrypted.pdf, dove <your_test_file> è il nome del file di test che hai caricato.

    aws s3api get-object --bucket SOURCEBUCKET-encrypted --key test_encrypted.pdf my_encrypted_file.pdf

    Questo comando scarica il file nella directory corrente e lo salva come. my_encrypted_file.pdf

  4. Conferma di poter aprire il file scaricato con la password con cui la funzione Lambda lo ha protetto ()my-secret-password.

Test dell'app con lo script automatico

Per testare l'app utilizzando lo script di test fornito, assicurati innanzitutto che il pytest modulo sia installato nell'ambiente locale. È possibile eseguire l'installazione pytest eseguendo il comando seguente:

pip install pytest

È inoltre necessario modificare il codice nel test_pdf_encrypt.py file per sostituire i nomi dei bucket segnaposto con i nomi dei bucket di origine e destinazione di Amazon S3. Apportare le modifiche seguenti a test_pdf_encrypt.py:

  • Nella test_source_bucket_available funzione, sostituiscilo EXAMPLE-BUCKET con il nome del bucket di origine.

  • Nella test_encrypted_file_in_bucket funzione, sostituisci EXAMPLE-BUCKET-encrypted con<source-bucket>-encrypted, dove <source-bucket> è il nome del tuo bucket di origine.

  • Nella cleanup funzione, sostituisci EXAMPLE-BUCKET con il nome del bucket di origine e sostituisci EXAMPLE-BUCKET-encrypted con≪source-bucket>-encrypted, dove <source-bucket> è il nome del bucket di origine.

Per eseguire i test, procedi come segue:

  • Salvate un PDF file denominato test.pdf nella directory contenente i pytest.ini file test_pdf_encrypt.py and.

  • Apri un terminale o un programma shell ed esegui il seguente comando dalla directory contenente i file di test.

    pytest -s -v

Al termine del test, dovresti vedere un risultato simile al seguente:


============================================================== test session starts =========================================================
platform linux -- Python 3.12.2, pytest-7.2.2, pluggy-1.0.0 -- /usr/bin/python3
cachedir: .pytest_cache
hypothesis profile 'default' -> database=DirectoryBasedExampleDatabase('/home/pdf_encrypt_app/.hypothesis/examples')
Test order randomisation NOT enabled. Enable with --random-order or --random-order-bucket=<bucket_type>
rootdir: /home/pdf_encrypt_app, configfile: pytest.ini
plugins: anyio-3.7.1, hypothesis-6.70.0, localserver-0.7.1, random-order-1.1.0
collected 4 items

test_pdf_encrypt.py::test_source_bucket_available PASSED
test_pdf_encrypt.py::test_lambda_invoked PASSED
test_pdf_encrypt.py::test_encrypted_file_in_bucket PASSED
test_pdf_encrypt.py::test_cleanup PASSED
Deleted test.pdf from EXAMPLE-BUCKET
Deleted test_encrypted.pdf from EXAMPLE-BUCKET-encrypted


=============================================================== 4 passed in 7.32s ==========================================================

Passaggi successivi

Ora che hai creato questa app di esempio, puoi utilizzare il codice fornito come base per creare altri tipi di applicazioni per l'elaborazione di file. Modifica il codice nel lambda_function.py file per implementare la logica di elaborazione dei file per il tuo caso d'uso.

Molti casi d'uso tipici dell'elaborazione di file riguardano l'elaborazione delle immagini. Quando si usa Python, le librerie di elaborazione delle immagini più popolari come pillow contengono in genere componenti C o C++. Per garantire che il pacchetto di distribuzione della funzione sia compatibile con l'ambiente di esecuzione Lambda, è importante utilizzare il binario di distribuzione del codice sorgente corretto.

Quando si distribuiscono le risorse con AWS SAM, è necessario adottare alcune misure aggiuntive per includere la corretta distribuzione dei sorgenti nel pacchetto di distribuzione. Poiché AWS SAM non installerà dipendenze per una piattaforma diversa dalla macchina di compilazione, specificare la corretta distribuzione del codice sorgente (.whlfile) nel requirements.txt file non funzionerà se la macchina di compilazione utilizza un sistema operativo o un'architettura diversi dall'ambiente di esecuzione Lambda. Invece, dovresti eseguire una delle seguenti operazioni: