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à.
# Elabora i file senza server utilizzando Lambda
I flussi di lavoro di elaborazione dei file spesso iniziano con file che arrivano su una condivisione di file NFS o SMB: documenti scansionati dalle filiali, immagini caricate dai team sul campo, audio acquisito dai contact center o file di dati forniti dai partner.
Con un access point Amazon S3 collegato al volume FSx for ONTAP, AWS Lambda le funzioni leggono e scrivono i file direttamente utilizzando l'API Amazon S3. File-level le operazioni possono essere elaborate senza server sugli stessi dati a cui accedono utenti e applicazioni tramite NFS e SMB.
Questo tutorial mostra tre modelli comuni di elaborazione dei file. Ogni esempio legge un file dal volume attraverso il punto di accesso, lo elabora con un AWS servizio o una libreria e riscrive il risultato nel volume.
| Esempio | Input | Processing | Output |
| --- | --- | --- | --- |
| [Esempio 1: generazione di miniature di immagini](#tutorial-lambda-thumbnail) | Immagine JPEG | Pillow (libreria di immagini) | Miniatura ridimensionata |
| [Esempio 2: Estrarre testo dai documenti](#tutorial-lambda-textract) | Documento PDF | Amazon Textract | Testo estratto (JSON) |
| [Esempio 3: Trascrivere file audio](#tutorial-lambda-transcribe) | Audio MP3 | Amazon Transcribe | Trascrizione (JSON) |
**Nota**
Il completamento di questo tutorial richiede dai **40 ai 60 minuti circa.** Le risorse Servizi AWS utilizzate sono soggette a costi per le risorse create. Se completi tempestivamente tutti i passaggi, inclusa la sezione **Pulizia**, il costo previsto è inferiore a **1 USD** negli Stati Uniti orientali (Virginia settentrionale). Regione AWS Questa stima non include i costi correnti per il volume FSx for ONTAP stesso.
## Prerequisiti
Prima di iniziare, assicurati di disporre di:
+ Un volume FSx for ONTAP con un access point Amazon S3 collegato. Per istruzioni sulla creazione di un punto di accesso, consulta. [Creazione di un access point](fsxn-creating-access-points.md)
+ L'alias del punto di accesso per il punto di accesso. Puoi trovarlo nella console Amazon FSx o eseguendolo. `aws fsx describe-s3-access-point-attachments`
+ AWS CLI versione 1 o versione 2 installata e configurata. I `aws lambda invoke` comandi di questo tutorial includono l'`--cli-binary-format raw-in-base64-out`opzione, richiesta nella AWS CLI versione 2 in modo che i payload JSON non elaborati non vengano interpretati come base64. Se utilizzate la AWS CLI versione 1, omettete tale opzione.
+ Autorizzazioni IAM per il chiamante (l'utente o il ruolo che esegue questo tutorial) per richiamare le funzioni Lambda `lambda:CreateFunction` (`lambda:InvokeFunction`,), accedere al punto di accesso Amazon S3 (,) e passare il ruolo di esecuzione Lambda `s3:GetObject` (`s3:PutObject`). `iam:PassRole`
**Nota**
Questo tutorial utilizza la configurazione Lambda predefinita, in cui le funzioni vengono eseguite in una rete gestita all'esterno del VPC. In tal caso, il punto di accesso deve avere un'origine di rete **Internet** in modo che la funzione possa raggiungerlo. Se colleghi la tua funzione Lambda a un VPC, puoi invece utilizzare un'origine di rete VPC sul punto di accesso; il VPC deve avere un gateway Amazon S3 o un endpoint di interfaccia. Per ulteriori informazioni, consulta [Configurazione dell'accesso alla rete per i punti di accesso Amazon S3](configuring-network-access-for-s3-access-points.md).
## Fase 1: Caricare file di esempio
Scaricate i seguenti file di esempio e caricateli sul volume FSx for ONTAP tramite il punto di accesso. `{{my-ap-alias-ext-s3alias}}`Sostituiteli con il vostro alias del punto di accesso nel corso di questo tutorial.
+ **Immagine di esempio:** scarica l'[immagine Blue Marble della NASA](https://eoimages.gsfc.nasa.gov/images/imagerecords/73000/73909/world.topo.bathy.200412.3x5400x2700.jpg) (dominio pubblico, 2,4 MB) e salvala con nome. `sample-image.jpg`
+ **Audio di esempio:** scarica il [file audio di esempio](https://d1.awsstatic.com/tmt/create-audio-transcript-transcribe/transcribe-sample.5fc2109bb28268d10fbc677e64b7e59256783d3c.mp3) dal tutorial [introduttivo di Amazon Transcribe](https://docs.aws.amazon.com/hands-on/latest/create-audio-transcript-transcribe/create-audio-transcript-transcribe.html) (410 KB) e salvalo con nome. `sample-audio.mp3`
Caricate i file di esempio sul volume FSx for ONTAP tramite il punto di accesso.
```
$ aws s3 cp sample-image.jpg s3://{{my-ap-alias-ext-s3alias}}/samples/images/sample-image.jpg
aws s3 cp sample-audio.mp3 s3://{{my-ap-alias-ext-s3alias}}/samples/audio/sample-audio.mp3
```
**Nota**
L'immagine di esempio è una fotografia della NASA Blue Marble (di pubblico dominio, 2,4 MB). L'audio di esempio è tratto dal tutorial [introduttivo di Amazon Transcribe](https://docs.aws.amazon.com/hands-on/latest/create-audio-transcript-transcribe/create-audio-transcript-transcribe.html) (410 KB). Il PDF di esempio viene generato in. [Esempio 2: Estrarre testo dai documenti](#tutorial-lambda-textract)
## Fase 2: Creare il ruolo di esecuzione Lambda
Le funzioni Lambda assumono un ruolo di esecuzione per interagire con altre. Servizi AWS Per questo tutorial, allega la `AWSLambdaBasicExecutionRole` policy AWS gestita per la registrazione CloudWatch dei log, quindi aggiungi una policy in linea che garantisca l'accesso al punto di accesso Amazon S3 e alle API Textract e Transcribe utilizzate dagli esempi.
### Creazione del ruolo di esecuzione di Lambda
`{{access-point-name}}`Sostituisci e con i tuoi valori. `{{region}}` `{{account-id}}`
1. Salva la seguente politica di attendibilità come`trust-policy.json`.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {"Service": "lambda.amazonaws.com"},
"Action": "sts:AssumeRole"
}
]
}
```
1. Salva la seguente politica di autorizzazioni in linea come. `permissions-policy.json` Garantisce l'accesso al punto di accesso e ai servizi aggiuntivi utilizzati dagli esempi.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": ["s3:GetObject", "s3:PutObject", "s3:ListBucket"],
"Resource": [
"arn:aws:s3:{{region}}:{{account-id}}:accesspoint/{{access-point-name}}",
"arn:aws:s3:{{region}}:{{account-id}}:accesspoint/{{access-point-name}}/object/*"
]
},
{
"Effect": "Allow",
"Action": ["textract:DetectDocumentText"],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"transcribe:StartTranscriptionJob",
"transcribe:GetTranscriptionJob"
],
"Resource": "*"
}
]
}
```
1. Crea il ruolo, allega la politica di registrazione gestita e allega la politica in linea.
```
$ aws iam create-role \
--role-name {{fsxn-lambda-file-processor}} \
--assume-role-policy-document file://trust-policy.json
aws iam attach-role-policy \
--role-name {{fsxn-lambda-file-processor}} \
--policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
aws iam put-role-policy \
--role-name {{fsxn-lambda-file-processor}} \
--policy-name fsxn-access-point-policy \
--policy-document file://permissions-policy.json
```
## Integrazione nel tuo flusso di lavoro
Gli esempi di questo tutorial utilizzano l'invocazione manuale con un evento di test. In produzione, è possibile attivare queste funzioni automaticamente utilizzando i seguenti approcci:
+ ** EventBridge Pianificazione Amazon.** Esegui la funzione secondo una pianificazione ricorrente (ad esempio, ogni ora o ogni giorno) per elaborare nuovi file. La funzione può elencare i file tramite il punto di accesso ed elaborare quelli che non sono ancora stati elaborati. Per ulteriori informazioni, consulta [Schedule Lambda functions Lambda EventBridge nella Amazon EventBridge](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-run-lambda-schedule.html) *User Guide*.
+ **Amazon API Gateway.** Esponi la funzione come API HTTP in modo che utenti o applicazioni possano richiedere l'elaborazione di un file specifico su richiesta. Per ulteriori informazioni, consulta [Crea un'API REST di API Gateway con integrazione Lambda](https://docs.aws.amazon.com/apigateway/latest/developerguide/getting-started-with-lambda-integration.html) nella *Amazon API Gateway Developer Guide*.
+ **Step Functions.** Orchestra le pipeline di elaborazione dei file in più fasi che combinano più funzioni Lambda. Ad esempio, un flusso di lavoro che estrae il testo da un documento, lo traduce e riscrive il risultato nel volume. Per ulteriori informazioni, consulta [Call Lambda with Step Functions](https://docs.aws.amazon.com/step-functions/latest/dg/connect-lambda.html) nella *AWS Step Functions Developer* Guide.
## Esempio 1: generazione di miniature di immagini
Questo esempio legge un'immagine JPEG dal volume FSx for ONTAP, la ridimensiona in una miniatura da 200 pixel utilizzando la libreria di immagini Pillow e riscrive la miniatura nel volume.
**Codice della funzione Lambda**
`lambda_function.py`Salvate il codice seguente come.
```
import boto3
from io import BytesIO
from PIL import Image
s3 = boto3.client('s3')
def lambda_handler(event, context):
bucket = event['access_point_alias']
key = event['key']
# Read the image from FSx through the access point
response = s3.get_object(Bucket=bucket, Key=key)
image_data = response['Body'].read()
# Resize to thumbnail
img = Image.open(BytesIO(image_data))
img.thumbnail((200, 200))
# Write the thumbnail back to FSx
buffer = BytesIO()
img.save(buffer, format='JPEG', quality=85)
buffer.seek(0)
thumbnail_key = key.rsplit('.', 1)[0] + '_thumbnail.jpg'
s3.put_object(
Bucket=bucket,
Key=thumbnail_key,
Body=buffer.getvalue(),
ContentType='image/jpeg'
)
return {
'original_size': len(image_data),
'thumbnail_size': len(buffer.getvalue()),
'thumbnail_key': thumbnail_key
}
```
**Crea e richiama la funzione**
Questa funzione richiede la libreria Pillow. Crea un pacchetto di distribuzione che includa Pillow creato per il runtime Lambda Linux.
```
$ # Create a deployment package with Pillow for Lambda (Linux)
mkdir package && pip install Pillow -t package/ \
--platform manylinux2014_x86_64 --only-binary=:all:
cd package && zip -r ../thumbnail-function.zip .
cd .. && zip thumbnail-function.zip lambda_function.py
# Create the function
aws lambda create-function \
--function-name {{fsxn-thumbnail-generator}} \
--runtime python3.12 \
--handler lambda_function.lambda_handler \
--role arn:aws:iam::{{account-id}}:role/{{fsxn-lambda-file-processor}} \
--zip-file fileb://thumbnail-function.zip \
--timeout 30 \
--memory-size 256
# Invoke with a test event
aws lambda invoke \
--function-name {{fsxn-thumbnail-generator}} \
--cli-binary-format raw-in-base64-out \
--payload '{"access_point_alias": "{{my-ap-alias-ext-s3alias}}", "key": "samples/images/sample-image.jpg"}' \
response.json
cat response.json
```
**Verifica il risultato**
```
$ aws s3 ls s3://{{my-ap-alias-ext-s3alias}}/samples/images/
2024-01-23 12:19:32 2566770 sample-image.jpg
2024-01-23 12:25:49 7065 sample-image_thumbnail.jpg
```
L'immagine originale da 2,4 MB (5400 × 2700 pixel) è stata ridimensionata in una miniatura da 7 KB (200 × 100 pixel).
## Esempio 2: Estrarre testo dai documenti
Questo esempio legge un documento PDF dal volume FSx for ONTAP, lo invia ad Amazon Textract per estrarre il testo e riscrive il testo estratto come file JSON nel volume.
**Crea e carica un PDF di esempio**
Per questo esempio, è necessario un documento PDF sul volume FSx for ONTAP. Il seguente script Python genera un semplice PDF di fattura e lo carica tramite il punto di accesso. Esegui questo script sul tuo computer locale (non in Lambda).
```
$ pip install fpdf2 boto3
```
```
# create_invoice.py — run locally to generate and upload a sample PDF
from fpdf import FPDF
import boto3
pdf = FPDF()
pdf.add_page()
pdf.set_font("Helvetica", "B", 24)
pdf.cell(0, 15, "INVOICE", new_x="LMARGIN", new_y="NEXT", align="C")
pdf.set_font("Helvetica", "", 12)
pdf.cell(0, 8, "Invoice Number: INV-2024-00142", new_x="LMARGIN", new_y="NEXT")
pdf.cell(0, 8, "Date: January 15, 2024", new_x="LMARGIN", new_y="NEXT")
pdf.cell(0, 8, "Customer: Example Corp", new_x="LMARGIN", new_y="NEXT")
pdf.ln(5)
pdf.set_font("Helvetica", "B", 12)
pdf.cell(80, 8, "Description", border=1)
pdf.cell(30, 8, "Qty", border=1, align="C")
pdf.cell(40, 8, "Unit Price", border=1, align="R")
pdf.cell(40, 8, "Amount", border=1, align="R")
pdf.ln()
pdf.set_font("Helvetica", "", 12)
for desc, qty, price, amt in [
("Cloud Storage Service", "1", "$2,400.00", "$2,400.00"),
("Data Transfer (TB)", "5", "$90.00", "$450.00"),
("Technical Support", "1", "$500.00", "$500.00"),
]:
pdf.cell(80, 8, desc, border=1)
pdf.cell(30, 8, qty, border=1, align="C")
pdf.cell(40, 8, price, border=1, align="R")
pdf.cell(40, 8, amt, border=1, align="R")
pdf.ln()
s3 = boto3.client('s3')
s3.put_object(
Bucket='{{my-ap-alias-ext-s3alias}}',
Key='samples/documents/invoice.pdf',
Body=pdf.output(),
ContentType='application/pdf'
)
print("Uploaded invoice.pdf")
```
```
$ python3 create_invoice.py
```
**Codice della funzione Lambda**
Salva il codice seguente come`lambda_function.py`.
```
import boto3
import json
s3 = boto3.client('s3')
textract = boto3.client('textract')
def lambda_handler(event, context):
bucket = event['access_point_alias']
key = event['key']
# Read the PDF from FSx through the access point
response = s3.get_object(Bucket=bucket, Key=key)
document_bytes = response['Body'].read()
# Extract text with Textract
textract_response = textract.detect_document_text(
Document={'Bytes': document_bytes}
)
lines = [
block['Text']
for block in textract_response['Blocks']
if block['BlockType'] == 'LINE'
]
# Write extracted text as JSON back to FSx
result = {
'source_file': key,
'total_lines': len(lines),
'extracted_text': lines
}
output_key = key.rsplit('.', 1)[0] + '_extracted.json'
s3.put_object(
Bucket=bucket,
Key=output_key,
Body=json.dumps(result, indent=2),
ContentType='application/json'
)
return {
'lines_extracted': len(lines),
'output_key': output_key
}
```
**Crea e richiama la funzione**
```
$ zip textract-function.zip lambda_function.py
aws lambda create-function \
--function-name {{fsxn-text-extractor}} \
--runtime python3.12 \
--handler lambda_function.lambda_handler \
--role arn:aws:iam::{{account-id}}:role/{{fsxn-lambda-file-processor}} \
--zip-file fileb://textract-function.zip \
--timeout 30 \
--memory-size 256
aws lambda invoke \
--function-name {{fsxn-text-extractor}} \
--cli-binary-format raw-in-base64-out \
--payload '{"access_point_alias": "{{my-ap-alias-ext-s3alias}}", "key": "samples/documents/invoice.pdf"}' \
response.json
cat response.json
```
Output di esempio:
```
{"lines_extracted": 22, "output_key": "samples/documents/invoice_extracted.json"}
```
## Esempio 3: Trascrivere file audio
Questo esempio avvia un processo Amazon Transcribe per un file audio archiviato sul volume FSx for ONTAP. Amazon Transcribe legge il file audio direttamente dal punto di accesso utilizzando l'alias del punto di accesso nell'URI del file multimediale. Al termine del processo, la funzione riscrive la trascrizione nel volume.
**Codice della funzione Lambda**
Salva il codice seguente come. `lambda_function.py`
```
import boto3
import json
import time
import urllib.request
s3 = boto3.client('s3')
transcribe = boto3.client('transcribe')
def lambda_handler(event, context):
bucket = event['access_point_alias']
key = event['key']
media_format = key.rsplit('.', 1)[-1] # mp3, wav, etc.
# Start a Transcribe job pointing to the file on FSx
job_name = f"fsxn-{int(time.time())}"
transcribe.start_transcription_job(
TranscriptionJobName=job_name,
Media={'MediaFileUri': f's3://{bucket}/{key}'},
MediaFormat=media_format,
LanguageCode='en-US'
)
# Wait for the job to complete
while True:
status = transcribe.get_transcription_job(
TranscriptionJobName=job_name
)
state = status['TranscriptionJob']['TranscriptionJobStatus']
if state in ('COMPLETED', 'FAILED'):
break
time.sleep(5)
if state == 'FAILED':
raise Exception(
status['TranscriptionJob'].get('FailureReason', 'Unknown error')
)
# Download the transcript
transcript_uri = status['TranscriptionJob']['Transcript']['TranscriptFileUri']
with urllib.request.urlopen(transcript_uri) as resp:
transcript_data = json.loads(resp.read())
transcript_text = transcript_data['results']['transcripts'][0]['transcript']
# Write the transcript back to FSx
result = {
'source_file': key,
'job_name': job_name,
'transcript': transcript_text
}
output_key = key.rsplit('.', 1)[0] + '_transcript.json'
s3.put_object(
Bucket=bucket,
Key=output_key,
Body=json.dumps(result, indent=2),
ContentType='application/json'
)
return {
'transcript_length': len(transcript_text),
'output_key': output_key
}
```
**Crea e richiama la funzione**
```
$ zip transcribe-function.zip lambda_function.py
aws lambda create-function \
--function-name {{fsxn-audio-transcriber}} \
--runtime python3.12 \
--handler lambda_function.lambda_handler \
--role arn:aws:iam::{{account-id}}:role/{{fsxn-lambda-file-processor}} \
--zip-file fileb://transcribe-function.zip \
--timeout 120
aws lambda invoke \
--function-name {{fsxn-audio-transcriber}} \
--cli-binary-format raw-in-base64-out \
--payload '{"access_point_alias": "{{my-ap-alias-ext-s3alias}}", "key": "samples/audio/sample-audio.mp3"}' \
--cli-read-timeout 180 \
response.json
cat response.json
```
**Nota**
Il completamento del processo Transcribe richiede in genere da 15 a 45 secondi. Il timeout della funzione è impostato su 120 secondi per consentire ciò.
## Considerazioni
+ **L'origine Internet è richiesta per la configurazione predefinita.** Per impostazione predefinita, Lambda accede ad Amazon S3 da un'infrastruttura gestita esterna al tuo VPC, che richiede un punto di accesso di origine Internet. Se colleghi la tua funzione Lambda a un VPC, puoi invece utilizzare un VPC-origin punto di accesso. Per i dettagli, consulta i prerequisiti.
+ **Limiti di dimensione dei file.** Le funzioni Lambda hanno una memoria massima di 10 GB e un tempo di esecuzione massimo di 15 minuti. Per file di grandi dimensioni, prendi in considerazione l'utilizzo di range reads (`GetObject`con `Range` intestazione) o lo streaming della risposta.
+ **Limiti di Textract.** L'`DetectDocumentText`API sincrona accetta documenti fino a 10 MB e 1 pagina. Per documenti composti da più pagine, utilizza l'API `StartDocumentTextDetection` asincrona.
+ **Trascrivi le letture direttamente dal punto di accesso.** Amazon Transcribe accetta l'alias del punto di accesso nel `MediaFileUri` parametro (). `s3://{{ap-alias}}/{{key}}` La funzione Lambda non richiede di scaricare e ricaricare il file audio.
+ **Autorizzazioni utente del file system.** L'utente del file system associato al punto di accesso deve disporre dell'autorizzazione di lettura sui file di input e dell'autorizzazione di scrittura sulle directory di output.
## Eliminazione
Per evitare addebiti continui, elimina le risorse che hai creato in questo tutorial.
```
$ # Delete Lambda functions
aws lambda delete-function --function-name {{fsxn-thumbnail-generator}}
aws lambda delete-function --function-name {{fsxn-text-extractor}}
aws lambda delete-function --function-name {{fsxn-audio-transcriber}}
# Delete the IAM role and policies
aws iam delete-role-policy \
--role-name {{fsxn-lambda-file-processor}} \
--policy-name fsxn-access-point-policy
aws iam detach-role-policy \
--role-name {{fsxn-lambda-file-processor}} \
--policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
aws iam delete-role --role-name {{fsxn-lambda-file-processor}}
# Delete sample files from your FSx volume
aws s3 rm s3://{{my-ap-alias-ext-s3alias}}/samples/ --recursive
```