Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Serverlose Verarbeitung von Dateien mit Lambda
Workflows zur Dateiverarbeitung beginnen häufig mit Dateien, die auf einer NFS- oder SMB-Dateifreigabe ankommen — gescannte Dokumente aus Zweigstellen, von Außendienstteams hochgeladene Bilder, von Kontaktzentren aufgenommene Audiodaten oder von Partnern bereitgestellte Datendateien.
Wenn ein Amazon S3 S3-Zugriffspunkt an das FSx for ONTAP-Volume angeschlossen ist, lesen und schreiben AWS Lambda Funktionen die Dateien direkt über die Amazon S3 S3-API. File-level Operationen können serverlos mit denselben Daten verarbeitet werden, auf die Ihre Benutzer und Anwendungen über NFS und SMB zugreifen.
Dieses Tutorial zeigt drei gängige Dateiverarbeitungsmuster. Jedes Beispiel liest eine Datei vom Volume über den Access Point, verarbeitet sie mit einem AWS Dienst oder einer Bibliothek und schreibt das Ergebnis zurück auf das Volume.
| Beispiel | Input | Verarbeitung | Ausgabe |
| --- | --- | --- | --- |
| [Beispiel 1: Generieren Sie Miniaturansichten](#tutorial-lambda-thumbnail) | JPEG-Bild | Kissen (Bildbibliothek) | Die Größe des Miniaturbilds wurde geändert |
| [Beispiel 2: Extrahieren Sie Text aus Dokumenten](#tutorial-lambda-textract) | PDF-Dokument | Amazon Textract | Extrahierter Text (JSON) |
| [Beispiel 3: Audiodateien Transcribe](#tutorial-lambda-transcribe) | MP3-Audio | Amazon Transcribe | Transkript (JSON) |
**Anmerkung**
Die Bearbeitung dieses Tutorials dauert etwa **40 bis 60 Minuten**. Für die AWS-Services verwendeten Ressourcen fallen Gebühren für die von Ihnen erstellten Ressourcen an. Wenn Sie alle Schritte, einschließlich des Abschnitts **Aufräumen**, umgehend abschließen, belaufen sich die voraussichtlichen Kosten im Osten der USA (Nord-Virginia) AWS-Region auf weniger als **1$**. In dieser Schätzung sind die laufenden Gebühren für das FSx for ONTAP-Volumen selbst nicht enthalten.
## Voraussetzungen
Stellen Sie vor dem Beginn sicher, dass Sie über das Folgende verfügen:
+ Ein FSx for ONTAP-Volume mit angeschlossenem Amazon S3 S3-Zugriffspunkt. Anweisungen zum Erstellen eines Access Points finden Sie unter. [Erstellen eines Zugriffspunkts](fsxn-creating-access-points.md)
+ Der Access Point-Alias für Ihren Access Point. Sie finden dies in der Amazon FSx-Konsole oder indem Sie es ausführen`aws fsx describe-s3-access-point-attachments`.
+ AWS CLI Version 1 oder Version 2 installiert und konfiguriert. Die `aws lambda invoke` Befehle in diesem Tutorial beinhalten die `--cli-binary-format raw-in-base64-out` Option, die in AWS CLI Version 2 erforderlich ist, damit unformatierte JSON-Payloads nicht als Base64 interpretiert werden. Wenn Sie AWS CLI Version 1 verwenden, lassen Sie diese Option weg.
+ IAM-Berechtigungen für den Aufrufer (den Benutzer oder die Rolle, die dieses Tutorial ausführt), um Lambda-Funktionen (`lambda:CreateFunction`,`lambda:InvokeFunction`) aufzurufen, auf den Amazon S3 S3-Zugriffspunkt (`s3:GetObject`,`s3:PutObject`) zuzugreifen und die Lambda-Ausführungsrolle () zu übergeben. `iam:PassRole`
**Anmerkung**
In diesem Tutorial wird die standardmäßige Lambda-Konfiguration verwendet, bei der Funktionen in einem verwalteten Netzwerk außerhalb Ihrer VPC ausgeführt werden. In diesem Fall muss der Access Point einen Ursprung **im Internet-Netzwerk** haben, damit die Funktion ihn erreichen kann. Wenn Sie Ihre Lambda-Funktion an eine VPC anhängen, können Sie stattdessen einen VPC-Netzwerkursprung auf dem Access Point verwenden. Die VPC muss über einen Amazon S3 S3-Gateway- oder Interface-Endpunkt verfügen. Weitere Informationen finden Sie unter [Konfiguration des Netzwerkzugriffs für Amazon S3-Zugangspunkte](configuring-network-access-for-s3-access-points.md).
## Schritt 1: Laden Sie die Beispieldateien hoch
Laden Sie die folgenden Beispieldateien herunter und laden Sie sie über den Access Point auf Ihr FSx for ONTAP-Volume hoch. `{{my-ap-alias-ext-s3alias}}`Ersetzen Sie es in diesem Tutorial durch Ihren Access Point-Alias.
+ **Beispielbild:** Laden Sie das [NASA Blue Marble-Bild](https://eoimages.gsfc.nasa.gov/images/imagerecords/73000/73909/world.topo.bathy.200412.3x5400x2700.jpg) (gemeinfrei, 2,4 MB) herunter und speichern Sie es unter`sample-image.jpg`.
+ **Audiobeispiel:** Laden Sie die [Beispiel-Audiodatei](https://d1.awsstatic.com/tmt/create-audio-transcript-transcribe/transcribe-sample.5fc2109bb28268d10fbc677e64b7e59256783d3c.mp3) aus dem [Amazon Transcribe-Tutorial „Erste Schritte](https://docs.aws.amazon.com/hands-on/latest/create-audio-transcript-transcribe/create-audio-transcript-transcribe.html)“ (410 KB) herunter und speichern Sie sie unter. `sample-audio.mp3`
Laden Sie die Beispieldateien über den Access Point auf Ihr FSx for ONTAP-Volume hoch.
```
$ 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
```
**Anmerkung**
Das Beispielbild ist ein Blue Marble-Foto der NASA (gemeinfrei, 2,4 MB). Das Audiobeispiel stammt aus dem [Amazon Transcribe-Tutorial „Erste Schritte](https://docs.aws.amazon.com/hands-on/latest/create-audio-transcript-transcribe/create-audio-transcript-transcribe.html)“ (410 KB). Das Beispiel-PDF wird in generiert. [Beispiel 2: Extrahieren Sie Text aus Dokumenten](#tutorial-lambda-textract)
## Schritt 2: Erstellen Sie die Lambda-Ausführungsrolle
Lambda-Funktionen übernehmen eine Ausführungsrolle, um mit anderen AWS-Services zu interagieren. Fügen Sie für dieses Tutorial die `AWSLambdaBasicExecutionRole` Richtlinie AWS-managed für die CloudWatch Protokollierung von Logs hinzu und fügen Sie dann eine Inline-Richtlinie hinzu, die Zugriff auf den Amazon S3 S3-Zugriffspunkt und die Textract- und Transcribe-APIs gewährt, die in den Beispielen verwendet werden.
### So erstellen Sie eine Lambda-Ausführungsrolle
Ersetzen Sie `{{region}}``{{account-id}}`, und `{{access-point-name}}` durch Ihre Werte.
1. Speichern Sie die folgende Vertrauensrichtlinie unter`trust-policy.json`.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {"Service": "lambda.amazonaws.com"},
"Action": "sts:AssumeRole"
}
]
}
```
1. Speichern Sie die folgende Inline-Berechtigungsrichtlinie als`permissions-policy.json`. Sie gewährt Zugriff auf den Access Point und auf die zusätzlichen Dienste, die in den Beispielen verwendet werden.
```
{
"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. Erstellen Sie die Rolle, fügen Sie die Richtlinie für die verwaltete Protokollierung hinzu und fügen Sie die Inline-Richtlinie an.
```
$ 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
```
## Integration in Ihren Arbeitsablauf
Die Beispiele in diesem Tutorial verwenden den manuellen Aufruf mit einem Testereignis. In der Produktion können Sie diese Funktionen mithilfe der folgenden Methoden automatisch auslösen:
+ ** EventBridge Amazon-Zeitplan.** Führen Sie die Funktion nach einem wiederkehrenden Zeitplan aus (z. B. stündlich oder täglich), um neue Dateien zu verarbeiten. Die Funktion kann Dateien über den Access Point auflisten und alle Dateien verarbeiten, die noch nicht verarbeitet wurden. Weitere Informationen finden Sie unter [Schedule Lambda-Funktionen mithilfe von](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-run-lambda-schedule.html) Lambda-Funktionen EventBridge im * EventBridgeAmazon-Benutzerhandbuch*.
+ **Amazon API Gateway.** Stellen Sie die Funktion als HTTP-API bereit, sodass Benutzer oder Anwendungen bei Bedarf die Verarbeitung einer bestimmten Datei anfordern können. Weitere Informationen finden Sie unter [Erstellen einer API-Gateway-REST-API mit Lambda-Integration](https://docs.aws.amazon.com/apigateway/latest/developerguide/getting-started-with-lambda-integration.html) im *Amazon API Gateway Developer Guide*.
+ **Step Functions.** Orchestrieren Sie mehrstufige Dateiverarbeitungspipelines, die mehrere Lambda-Funktionen kombinieren. Zum Beispiel ein Workflow, der Text aus einem Dokument extrahiert, übersetzt und das Ergebnis wieder in den Volume schreibt. Weitere Informationen finden Sie unter [Call Lambda with Step Functions](https://docs.aws.amazon.com/step-functions/latest/dg/connect-lambda.html) im *AWS Step Functions Entwicklerhandbuch*.
## Beispiel 1: Generieren Sie Miniaturansichten
In diesem Beispiel wird ein JPEG-Bild aus Ihrem FSx for ONTAP-Volume gelesen, es mithilfe der Pillow-Bildbibliothek auf ein 200-Pixel-Miniaturbild verkleinert und das Vorschaubild wieder auf das Volume geschrieben.
**Lambda-Funktionscode**
Speichern Sie den folgenden Code unter. `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
}
```
**Erstellen Sie die Funktion und rufen Sie sie auf**
Für diese Funktion ist die Pillow-Bibliothek erforderlich. Erstellen Sie ein Bereitstellungspaket, das Pillow enthält, das für die Lambda-Linux-Laufzeit entwickelt wurde.
```
$ # 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
```
**Überprüfen Sie das Ergebnis**
```
$ 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
```
Das ursprüngliche 2,4-MB-Bild (5400 × 2700 Pixel) wurde auf ein 7-KB-Miniaturbild (200 × 100 Pixel) verkleinert.
## Beispiel 2: Extrahieren Sie Text aus Dokumenten
Dieses Beispiel liest ein PDF-Dokument aus Ihrem FSx for ONTAP-Volume, sendet es an Amazon Textract, um den Text zu extrahieren, und schreibt den extrahierten Text als JSON-Datei zurück auf das Volume.
**Erstellen Sie ein Beispiel-PDF und laden Sie es hoch**
Für dieses Beispiel benötigen Sie ein PDF-Dokument auf Ihrem FSx for ONTAP-Volume. Das folgende Python-Skript generiert ein einfaches Rechnungs-PDF und lädt es über den Access Point hoch. Führen Sie dieses Skript auf Ihrem lokalen Computer aus (nicht 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
```
**Lambda-Funktionscode**
Speichern Sie den folgenden Code als`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
}
```
**Erstellen Sie die Funktion und rufen Sie sie auf**
```
$ 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
```
Beispielausgabe:
```
{"lines_extracted": 22, "output_key": "samples/documents/invoice_extracted.json"}
```
## Beispiel 3: Audiodateien Transcribe
In diesem Beispiel wird ein Amazon Transcribe Transcribe-Job für eine Audiodatei gestartet, die auf Ihrem FSx for ONTAP-Volume gespeichert ist. Amazon Transcribe liest die Audiodatei direkt vom Access Point unter Verwendung des Access Point-Alias in der Mediendatei-URI. Wenn der Job abgeschlossen ist, schreibt die Funktion das Transkript zurück auf das Volume.
**Lambda-Funktionscode**
Speichern Sie den folgenden Code unter. `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
}
```
**Erstellen Sie die Funktion und rufen Sie sie auf**
```
$ 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
```
**Anmerkung**
Die Ausführung des Transkriptionsauftrags dauert in der Regel 15 bis 45 Sekunden. Um dies zu ermöglichen, ist das Timeout der Funktion auf 120 Sekunden festgelegt.
## Überlegungen
+ **Für die Standardkonfiguration ist ein Internet-Ursprung erforderlich.** Standardmäßig greift Lambda über eine verwaltete Infrastruktur außerhalb Ihrer VPC auf Amazon S3 zu, wofür ein Access Point mit Internetursprung erforderlich ist. Wenn Sie Ihre Lambda-Funktion an eine VPC anhängen, können Sie stattdessen einen VPC-origin Access Point verwenden. Einzelheiten finden Sie in den Voraussetzungen.
+ **Dateigrößenbeschränkungen.** Lambda-Funktionen haben einen maximalen Speicher von 10 GB und eine maximale Ausführungszeit von 15 Minuten. Erwägen Sie bei großen Dateien die Verwendung von Bereichslesevorgängen (`GetObject`mit `Range` Header) oder das Streamen der Antwort.
+ **Textgrenzwerte.** Die synchrone `DetectDocumentText` API akzeptiert Dokumente mit einer Größe von bis zu 10 MB und einer Seite. Verwenden Sie für mehrseitige Dokumente die asynchrone `StartDocumentTextDetection` API.
+ **Transcribe Sie Lesevorgänge direkt vom Access Point aus.** Amazon Transcribe akzeptiert den Access Point-Alias im `MediaFileUri` Parameter ()`s3://{{ap-alias}}/{{key}}`. Die Lambda-Funktion muss die Audiodatei nicht herunterladen und erneut hochladen.
+ **Benutzerberechtigungen für das Dateisystem.** Der dem Access Point zugeordnete Dateisystembenutzer muss über Leseberechtigungen für Eingabedateien und Schreibberechtigungen für Ausgabeverzeichnisse verfügen.
## Bereinigen
Um laufende Gebühren zu vermeiden, löschen Sie die Ressourcen, die Sie in diesem Tutorial erstellt haben.
```
$ # 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
```