Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Procese archivos sin servidor con Lambda
Los flujos de trabajo de procesamiento de archivos suelen comenzar con los archivos que llegan a un recurso compartido de archivos NFS o SMB: documentos escaneados de las sucursales, imágenes subidas por los equipos de campo, audio capturado desde los centros de atención o archivos de datos entregados por los socios.
Con un punto de acceso Amazon S3 conectado al volumen FSx for ONTAP, AWS Lambda las funciones leen y escriben los archivos directamente mediante la API de Amazon S3. File-level las operaciones se pueden procesar sin servidor con los mismos datos a los que acceden sus usuarios y aplicaciones a través de NFS y SMB.
En este tutorial, se muestran tres patrones comunes de procesamiento de archivos. Cada ejemplo lee un archivo del volumen a través del punto de acceso, lo procesa con un AWS servicio o biblioteca y vuelve a escribir el resultado en el volumen.
| Ejemplo | Input | Procesando | Output |
| --- | --- | --- | --- |
| [Ejemplo 1: generar miniaturas de imágenes](#tutorial-lambda-thumbnail) | Imagen JPEG | Pillow (biblioteca de imágenes) | Miniatura redimensionada |
| [Ejemplo 2: Extraer texto de documentos](#tutorial-lambda-textract) | Documento PDF | Amazon Textract | Texto extraído (JSON) |
| [Ejemplo 3: Transcribe archivos de audio](#tutorial-lambda-transcribe) | Audio MP3 | Amazon Transcribe | Transcripción (JSON) |
**nota**
Este tutorial tarda aproximadamente entre **40 y 60 minutos** en completarse. Los Servicios de AWS usuarios incurren en cargos por los recursos que cree. Si completa todos los pasos, incluida la sección de **limpieza**, con prontitud, el coste previsto será inferior a **1 dólar** en la zona este de EE. UU. (Virginia del Norte) Región de AWS. Esta estimación no incluye los cargos continuos del FSx para el propio volumen de ONTAP.
## Requisitos previos
Antes de empezar, asegúrese de que tiene lo siguiente:
+ Un volumen FSx para ONTAP con un punto de acceso Amazon S3 conectado. Para obtener instrucciones sobre cómo crear un punto de acceso, consulte. [Creación de un punto de acceso](fsxn-creating-access-points.md)
+ El alias del punto de acceso de su punto de acceso. Puede encontrarlo en la consola de Amazon FSx o ejecutándolo. `aws fsx describe-s3-access-point-attachments`
+ AWS CLI versión 1 o versión 2 instalada y configurada. Los `aws lambda invoke` comandos de este tutorial incluyen la `--cli-binary-format raw-in-base64-out` opción, que es necesaria en la AWS CLI versión 2, para que las cargas útiles JSON sin procesar no se interpreten como base64. Si usa la AWS CLI versión 1, omita esa opción.
+ Permisos de IAM para que la persona que llama (el usuario o el rol que ejecuta este tutorial) invoque las funciones de Lambda `lambda:CreateFunction` (`lambda:InvokeFunction`,), acceda al punto de acceso de Amazon S3 `s3:GetObject` (`s3:PutObject`,) y pase la función de ejecución de Lambda (). `iam:PassRole`
**nota**
En este tutorial, se utiliza la configuración Lambda predeterminada, en la que las funciones se ejecutan en una red gestionada fuera de la VPC. En ese caso, el punto de acceso debe tener un origen de red de **Internet** para que la función pueda acceder a él. Si adjunta la función Lambda a una VPC, puede utilizar en su lugar un origen de red de VPC en el punto de acceso; la VPC debe tener un punto de enlace o interfaz de Amazon S3. Para obtener más información, consulte [Configuración del acceso a la red para los puntos de acceso de Amazon S3](configuring-network-access-for-s3-access-points.md).
## Paso 1: Cargue archivos de muestra
Descargue los siguientes archivos de ejemplo y cárguelos en su volumen FSx for ONTAP a través del punto de acceso. `{{my-ap-alias-ext-s3alias}}`Sustitúyalo por el alias de tu punto de acceso a lo largo de este tutorial.
+ **Imagen de ejemplo:** descargue la [imagen Blue Marble de la NASA](https://eoimages.gsfc.nasa.gov/images/imagerecords/73000/73909/world.topo.bathy.200412.3x5400x2700.jpg) (dominio público, 2,4 MB) y guárdela como`sample-image.jpg`.
+ **Ejemplo de audio:** descargue el [archivo de audio de muestra](https://d1.awsstatic.com/tmt/create-audio-transcript-transcribe/transcribe-sample.5fc2109bb28268d10fbc677e64b7e59256783d3c.mp3) del [tutorial de introducción a Amazon Transcribe](https://docs.aws.amazon.com/hands-on/latest/create-audio-transcript-transcribe/create-audio-transcript-transcribe.html) (410 KB) y guárdelo como. `sample-audio.mp3`
Cargue los archivos de muestra en su volumen FSx for ONTAP a través del punto de acceso.
```
$ 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**
La imagen de muestra es una fotografía de mármol azul de la NASA (dominio público, 2,4 MB). El audio de muestra proviene del [tutorial de introducción a Amazon Transcribe](https://docs.aws.amazon.com/hands-on/latest/create-audio-transcript-transcribe/create-audio-transcript-transcribe.html) (410 KB). El PDF de muestra se genera en[Ejemplo 2: Extraer texto de documentos](#tutorial-lambda-textract).
## Paso 2: Crear el rol de ejecución de Lambda
Las funciones Lambda asumen una función de ejecución para interactuar con otras. Servicios de AWS Para este tutorial, adjunte la `AWSLambdaBasicExecutionRole` política AWS-managed para el registro de CloudWatch registros y, a continuación, añada una política en línea que conceda acceso al punto de acceso de Amazon S3 y a las API Textract y Transcribe que utilizan los ejemplos.
### Para crear el rol de ejecución de Lambda
Sustituya `{{region}}``{{account-id}}`, y por sus valores. `{{access-point-name}}`
1. Guarde la siguiente política de confianza como`trust-policy.json`.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {"Service": "lambda.amazonaws.com"},
"Action": "sts:AssumeRole"
}
]
}
```
1. Guarde la siguiente política de permisos en línea como`permissions-policy.json`. Concede acceso al punto de acceso y a los servicios adicionales que utilizan los ejemplos.
```
{
"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. Cree el rol, adjunte la política de registro administrado y adjunte la política en línea.
```
$ 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
```
## Integración en su flujo de trabajo
Los ejemplos de este tutorial utilizan la invocación manual con un evento de prueba. En producción, puede activar estas funciones automáticamente mediante los siguientes enfoques:
+ ** EventBridge Horario de Amazon.** Ejecute la función de forma periódica (por ejemplo, cada hora o todos los días) para procesar nuevos archivos. La función puede enumerar los archivos a través del punto de acceso y procesar los que aún no se hayan procesado. Para obtener más información, consulte [Programar funciones Lambda mediante EventBridge](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-run-lambda-schedule.html) la Guía del * EventBridgeusuario de Amazon*.
+ **Amazon API Gateway.** Exponga la función como una API HTTP para que los usuarios o las aplicaciones puedan solicitar el procesamiento de un archivo específico a pedido. Para obtener más información, consulte [Creación de una API REST de API Gateway con integración de Lambda](https://docs.aws.amazon.com/apigateway/latest/developerguide/getting-started-with-lambda-integration.html) en la Guía para *desarrolladores de Amazon API Gateway*.
+ **Step Functions.** Organice canalizaciones de procesamiento de archivos de varios pasos que combinen varias funciones de Lambda. Por ejemplo, un flujo de trabajo que extrae texto de un documento, lo traduce y vuelve a escribir el resultado en el volumen. Para obtener más información, consulte [Llamar a Lambda con Step Functions](https://docs.aws.amazon.com/step-functions/latest/dg/connect-lambda.html) en la Guía *AWS Step Functions para desarrolladores*.
## Ejemplo 1: generar miniaturas de imágenes
En este ejemplo, se lee una imagen JPEG del volumen de FSx para ONTAP, se le cambia el tamaño a una miniatura de 200 píxeles mediante la biblioteca de imágenes de Pillow y se vuelve a escribir la miniatura en el volumen.
**Código de la función de Lambda**
Guarde el siguiente código como. `lambda_function.py`
```
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
}
```
**Cree e invoque la función**
Esta función requiere la biblioteca Pillow. Cree un paquete de despliegue que incluya Pillow creado para el entorno de ejecución de 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
```
**Compruebe el resultado**
```
$ 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
```
La imagen original de 2,4 MB (5400 × 2700 píxeles) se redimensionó para convertirla en una miniatura de 7 KB (200 × 100 píxeles).
## Ejemplo 2: Extraer texto de documentos
En este ejemplo, se lee un documento PDF del volumen de FSx para ONTAP, se envía a Amazon Textract para extraer el texto y se vuelve a escribir el texto extraído como un archivo JSON en el volumen.
**Cree y cargue un PDF de muestra**
Para este ejemplo, necesita un documento PDF en su volumen FSx para ONTAP. El siguiente script de Python genera una factura PDF simple y la carga a través del punto de acceso. Ejecute este script en su máquina local (no en 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
```
**Código de la función de Lambda**
Guarde el siguiente código como`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
}
```
**Cree e invoque la función**
```
$ 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
```
Ejemplo de código de salida:
```
{"lines_extracted": 22, "output_key": "samples/documents/invoice_extracted.json"}
```
## Ejemplo 3: Transcribe archivos de audio
En este ejemplo, se inicia un trabajo de Amazon Transcribe para un archivo de audio almacenado en el volumen FSx for ONTAP. Amazon Transcribe lee el archivo de audio directamente desde el punto de acceso mediante el alias del punto de acceso en el URI del archivo multimedia. Cuando se completa el trabajo, la función vuelve a escribir la transcripción en el volumen.
**Código de la función de Lambda**
Guarde el siguiente código como`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
}
```
**Cree e invoque la función**
```
$ 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**
El trabajo de Transcribe suele tardar entre 15 y 45 segundos en completarse. Para ello, el tiempo de espera de la función está establecido en 120 segundos.
## Consideraciones
+ **Se requiere el origen de Internet para la configuración predeterminada.** De forma predeterminada, Lambda accede a Amazon S3 desde una infraestructura gestionada externa a su VPC, lo que requiere un punto de acceso de origen en Internet. Si adjunta la función Lambda a una VPC, puede utilizar un VPC-origin punto de acceso en su lugar. Consulte los requisitos previos para obtener más información.
+ **Límites de tamaño de archivo.** Las funciones Lambda tienen una memoria máxima de 10 GB y un tiempo máximo de ejecución de 15 minutos. En el caso de archivos de gran tamaño, considere la posibilidad de utilizar lecturas de rango (`GetObject`con `Range` encabezado) o transmitir la respuesta en streaming.
+ **Límites de Textract.** La `DetectDocumentText` API sincrónica acepta documentos de hasta 10 MB y 1 página. Para documentos de varias páginas, usa la API `StartDocumentTextDetection` asíncrona.
+ **Transcribe las lecturas directamente desde el punto de acceso.** Amazon Transcribe acepta el alias del punto de acceso en el `MediaFileUri` parámetro ()`s3://{{ap-alias}}/{{key}}`. La función Lambda no necesita descargar y volver a cargar el archivo de audio.
+ **Permisos de usuario del sistema de archivos.** El usuario del sistema de archivos asociado al punto de acceso debe tener permiso de lectura en los archivos de entrada y permiso de escritura en los directorios de salida.
## Limpieza
Para evitar cargos continuos, elimina los recursos que creaste en este 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
```