As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Processe arquivos sem servidor usando o Lambda
Os fluxos de trabalho de processamento de arquivos geralmente começam com arquivos que chegam em um compartilhamento de arquivos NFS ou SMB — documentos digitalizados de filiais, imagens enviadas por equipes de campo, áudio capturado de contact centers ou arquivos de dados fornecidos por parceiros.
Com um ponto de acesso Amazon S3 conectado ao volume FSx for ONTAP, AWS Lambda as funções leem e gravam os arquivos diretamente usando a API do Amazon S3. File-level as operações podem ser processadas sem servidor com base nos mesmos dados que seus usuários e aplicativos acessam via NFS e SMB.
Este tutorial mostra três padrões comuns de processamento de arquivos. Cada exemplo lê um arquivo do volume por meio do ponto de acesso, o processa com um AWS serviço ou biblioteca e grava o resultado de volta no volume.
| Exemplo | Input | Processamento | Output |
| --- | --- | --- | --- |
| [Exemplo 1: gerar miniaturas de imagens](#tutorial-lambda-thumbnail) | Imagem JPEG | Almofada (biblioteca de imagens) | Miniatura redimensionada |
| [Exemplo 2: extrair texto de documentos](#tutorial-lambda-textract) | Documento PDF | Amazon Textract | Texto extraído (JSON) |
| [Exemplo 3: Transcrever arquivos de áudio](#tutorial-lambda-transcribe) | Áudio MP3 | Amazon Transcribe | Transcrição (JSON) |
**nota**
Este tutorial leva aproximadamente **40 a 60 minutos** para ser concluído. Os Serviços da AWS usados incorrem em cobranças pelos recursos que você cria. Se você concluir todas as etapas, incluindo a seção **Limpeza** imediatamente, o custo esperado é inferior a **$1** no Leste dos EUA (Norte da Virgínia) Região da AWS. Essa estimativa não inclui cobranças contínuas do FSx para o volume do ONTAP em si.
## Pré-requisitos
Antes de começar, você deve ter o seguinte:
+ Um volume FSx for ONTAP com um ponto de acesso Amazon S3 conectado. Para obter instruções sobre como criar um ponto de acesso, consulte[Criar um ponto de acesso](fsxn-creating-access-points.md).
+ O alias do ponto de acesso do seu ponto de acesso. Você pode encontrar isso no console do Amazon FSx ou executando. `aws fsx describe-s3-access-point-attachments`
+ AWS CLI versão 1 ou versão 2 instalada e configurada. Os `aws lambda invoke` comandos neste tutorial incluem a `--cli-binary-format raw-in-base64-out` opção, que é necessária na AWS CLI versão 2 para que cargas JSON brutas não sejam interpretadas como base64. Se você usa a AWS CLI versão 1, omita essa opção.
+ Permissões do IAM para que o chamador (o usuário ou a função que executa este tutorial) invoque as funções do Lambda (`lambda:CreateFunction`,`lambda:InvokeFunction`), acesse o ponto de acesso do Amazon S3 (`s3:GetObject``s3:PutObject`,) e passe a função de execução do Lambda (). `iam:PassRole`
**nota**
Este tutorial usa a configuração padrão do Lambda, na qual as funções são executadas em uma rede gerenciada fora da sua VPC. Nesse caso, o ponto de acesso deve ter uma origem de rede **na Internet** para que a função possa alcançá-lo. Se você anexar sua função Lambda a uma VPC, poderá usar uma origem de rede VPC no ponto de acesso; a VPC deve ter um gateway Amazon S3 ou endpoint de interface. Para obter mais informações, consulte [Configurando o acesso à rede para pontos de acesso do Amazon S3](configuring-network-access-for-s3-access-points.md).
## Etapa 1: fazer upload de arquivos de amostra
Faça o download dos seguintes arquivos de amostra e carregue-os em seu volume FSx for ONTAP por meio do ponto de acesso. `{{my-ap-alias-ext-s3alias}}`Substitua pelo alias do seu ponto de acesso ao longo deste tutorial.
+ **Imagem de amostra:** baixe a [imagem do NASA Blue Marble](https://eoimages.gsfc.nasa.gov/images/imagerecords/73000/73909/world.topo.bathy.200412.3x5400x2700.jpg) (domínio público, 2,4 MB) e salve-a como`sample-image.jpg`.
+ **Amostra de áudio:** baixe o [arquivo de áudio de amostra](https://d1.awsstatic.com/tmt/create-audio-transcript-transcribe/transcribe-sample.5fc2109bb28268d10fbc677e64b7e59256783d3c.mp3) do tutorial de [introdução do Amazon Transcribe](https://docs.aws.amazon.com/hands-on/latest/create-audio-transcript-transcribe/create-audio-transcript-transcribe.html) (410 KB) e salve-o como. `sample-audio.mp3`
Faça o upload dos arquivos de amostra para o volume FSx for ONTAP por meio do ponto de acesso.
```
$ 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**
A imagem de amostra é uma fotografia da NASA Blue Marble (domínio público, 2,4 MB). A amostra de áudio é do tutorial de [introdução do Amazon Transcribe](https://docs.aws.amazon.com/hands-on/latest/create-audio-transcript-transcribe/create-audio-transcript-transcribe.html) (410 KB). O PDF de amostra é gerado em[Exemplo 2: extrair texto de documentos](#tutorial-lambda-textract).
## Etapa 2: Criar a função de execução do Lambda
As funções Lambda assumem uma função de execução para interagir com outras. Serviços da AWS Para este tutorial, anexe a `AWSLambdaBasicExecutionRole` política AWS gerenciada para registro de CloudWatch registros e, em seguida, adicione uma política em linha que conceda acesso ao ponto de acesso do Amazon S3 e às APIs Textract e Transcribe que os exemplos usam.
### Para criar o perfil de execução do Lambda
Substitua `{{region}}``{{account-id}}`,, e `{{access-point-name}}` por seus valores.
1. Salve a seguinte política de confiança como`trust-policy.json`.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {"Service": "lambda.amazonaws.com"},
"Action": "sts:AssumeRole"
}
]
}
```
1. Salve a seguinte política de permissões em linha como`permissions-policy.json`. Ele concede acesso ao ponto de acesso e aos serviços adicionais que os exemplos usam.
```
{
"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. Crie a função, anexe a política de registro gerenciado e anexe a política em linha.
```
$ 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
```
## Integração ao seu fluxo de trabalho
Os exemplos neste tutorial usam invocação manual com um evento de teste. Na produção, você pode acionar essas funções automaticamente usando as seguintes abordagens:
+ ** EventBridge Programação da Amazon.** Execute a função em uma programação recorrente (por exemplo, a cada hora ou diariamente) para processar novos arquivos. A função pode listar arquivos por meio do ponto de acesso e processar os que ainda não foram processados. Para obter mais informações, consulte [Programar funções do Lambda usando o Guia EventBridge EventBridge](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-run-lambda-schedule.html) *do usuário da Amazon*.
+ **Amazon API Gateway.** Exponha a função como uma API HTTP para que usuários ou aplicativos possam solicitar o processamento de um arquivo específico sob demanda. Para obter mais informações, consulte [Criar uma API REST do API Gateway com integração Lambda no Guia](https://docs.aws.amazon.com/apigateway/latest/developerguide/getting-started-with-lambda-integration.html) do *desenvolvedor do Amazon API Gateway*.
+ **Step Functions.** Organize pipelines de processamento de arquivos em várias etapas que combinam várias funções do Lambda. Por exemplo, um fluxo de trabalho que extrai texto de um documento, o traduz e grava o resultado de volta no volume. Para obter mais informações, consulte [Call Lambda with Step Functions](https://docs.aws.amazon.com/step-functions/latest/dg/connect-lambda.html) no Guia do *AWS Step Functions desenvolvedor*.
## Exemplo 1: gerar miniaturas de imagens
Este exemplo lê uma imagem JPEG do seu volume FSx for ONTAP, redimensiona-a para uma miniatura de 200 pixels usando a biblioteca de imagens Pillow e grava a miniatura de volta no volume.
**Código da função do Lambda**
Salve o código a seguir 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
}
```
**Crie e invoque a função**
Esta função requer a biblioteca Pillow. Crie um pacote de implantação que inclua o Pillow criado para o tempo de execução do 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
```
**Verifique o 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
```
A imagem original de 2,4 MB (5400 × 2700 pixels) foi redimensionada para uma miniatura de 7 KB (200 × 100 pixels).
## Exemplo 2: extrair texto de documentos
Este exemplo lê um documento PDF do seu volume FSx for ONTAP, o envia para o Amazon Textract para extrair o texto e grava o texto extraído como um arquivo JSON de volta no volume.
**Crie e faça upload de um PDF de amostra**
Neste exemplo, você precisa de um documento PDF no volume FSx for ONTAP. O script Python a seguir gera um PDF de fatura simples e o carrega por meio do ponto de acesso. Execute esse script em sua máquina local (não no 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 da função do Lambda**
Salve o código a seguir 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
}
```
**Crie e invoque a função**
```
$ 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
```
Resultado do exemplo:
```
{"lines_extracted": 22, "output_key": "samples/documents/invoice_extracted.json"}
```
## Exemplo 3: Transcrever arquivos de áudio
Este exemplo inicia um trabalho do Amazon Transcribe para um arquivo de áudio armazenado em seu volume FSx for ONTAP. O Amazon Transcribe lê o arquivo de áudio diretamente do ponto de acesso usando o alias do ponto de acesso no URI do arquivo de mídia. Quando o trabalho é concluído, a função grava a transcrição de volta no volume.
**Código da função do Lambda**
Salve o código a seguir 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
}
```
**Crie e invoque a função**
```
$ 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**
O trabalho de Transcrever normalmente leva de 15 a 45 segundos para ser concluído. O tempo limite da função é definido para 120 segundos para permitir isso.
## Considerações
+ **A origem da Internet é necessária para a configuração padrão.** Por padrão, o Lambda acessa o Amazon S3 a partir de uma infraestrutura gerenciada fora da sua VPC, o que requer um ponto de acesso com origem na Internet. Se você anexar sua função Lambda a uma VPC, poderá usar um VPC-origin ponto de acesso em vez disso. Consulte os pré-requisitos para obter detalhes.
+ **Limites de tamanho de arquivo.** As funções Lambda têm uma memória máxima de 10 GB e um tempo máximo de execução de 15 minutos. Para arquivos grandes, considere usar leituras de intervalo (`GetObject`com `Range` cabeçalho) ou transmitir a resposta.
+ **Limites do Textract.** A `DetectDocumentText` API síncrona aceita documentos de até 10 MB e 1 página. Para documentos de várias páginas, use a API `StartDocumentTextDetection` assíncrona.
+ **Transcreva as leituras diretamente do ponto de acesso.** O Amazon Transcribe aceita o alias do ponto de acesso no `MediaFileUri` parâmetro (). `s3://{{ap-alias}}/{{key}}` A função Lambda não precisa baixar e recarregar o arquivo de áudio.
+ **Permissões de usuário do sistema de arquivos.** O usuário do sistema de arquivos associado ao ponto de acesso deve ter permissão de leitura nos arquivos de entrada e permissão de gravação nos diretórios de saída.
## Limpeza
Para evitar cobranças contínuas, exclua os recursos que você criou neste 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
```