# Tutorial: Usar um acionador do Amazon S3 para criar imagens em miniatura
Neste tutorial, você criará e configurará uma função do Lambda que redimensiona as imagens adicionadas a um bucket do Amazon Simple Storage Service (Amazon S3). Quando você adiciona um arquivo de imagem ao bucket, o Amazon S3 invoca a função do Lambda. Em seguida, a função cria uma versão em miniatura da imagem e a envia para um bucket diferente do Amazon S3.
![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_resources.png)
Para concluir este tutorial, execute as seguintes tarefas:
1. Crie buckets do Amazon S3 de origem e de destino e faça upload de uma imagem de amostra.
1. Crie uma função do Lambda que redimensiona uma imagem e envia uma miniatura para um bucket do Amazon S3.
1. Configure um acionador do Lambda que invoca a função quando os objetos são carregados no bucket de origem.
1. Teste a função com um evento fictício e, em seguida, ao fazer upload de uma imagem para o bucket de origem.
Ao concluir essas etapas, você aprenderá a usar o Lambda para executar uma tarefa de processamento de arquivos em objetos adicionados a um bucket do Amazon S3. Você pode concluir este tutorial usando o AWS Command Line Interface ou a AWS CLI (Console de gerenciamento da AWS).
Caso esteja procurando um exemplo mais simples para aprender como configurar um acionador do Amazon S3 para o Lambda, você pode experimentar o [Tutorial: usar um acionador do Amazon S3 para invocar uma função do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/with-s3-example.html).
**Topics**
+ [Pré-requisitos](#with-s3-example-prereqs)
+ [Crie dois buckets do Amazon S3](#with-s3-tutorial-prepare-create-buckets)
+ [Faça upload de uma imagem de teste para o bucket de origem](#with-s3-tutorial-test-image)
+ [Criação de uma política de permissões](#with-s3-tutorial-create-policy)
+ [Criar uma função de execução](#with-s3-tutorial-create-execution-role)
+ [Crie o pacote de implantação de função](#with-s3-tutorial-create-function-package)
+ [Criar a função do Lambda](#with-s3-tutorial-create-function-createfunction)
+ [Configure o Amazon S3 para invocar a função](#with-s3-tutorial-configure-s3-trigger)
+ [Testar sua função do Lambda com um evento fictício](#with-s3-tutorial-dummy-test)
+ [Teste a função usando o acionador do Amazon S3](#with-s3-tutorial-test-s3)
+ [Limpe os recursos](#s3-tutorial-cleanup)
## Pré-requisitos
Se desejar usar a AWS CLI para concluir o tutorial, instale a [versão mais recente da AWS Command Line Interface]().
Para o código de função do Lambda, você pode usar Python ou Node.js. Instale as ferramentas compatíveis de linguagens e um gerenciador de pacotes para a linguagem que deseja usar.
### Instalar o AWS Command Line Interface
Se você ainda não instalou a AWS Command Line Interface, siga as etapas em [Instalar ou atualizar a versão mais recente da AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) para instalá-la.
O tutorial requer um terminal de linha de comando ou um shell para executar os comandos. No Linux e no macOS, use o gerenciador de pacotes e de shell de sua preferência.
**nota**
No Windows, alguns comandos da CLI do Bash que você costuma usar com o Lambda (como `zip`) não são compatíveis com os terminais integrados do sistema operacional. Para obter uma versão do Ubuntu com o Bash integrada no Windows, [instale o Subsistema do Windows para Linux](https://docs.microsoft.com/en-us/windows/wsl/install-win10).
## Crie dois buckets do Amazon S3
![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_steps1.png)
Primeiro, crie dois buckets do Amazon S3. O primeiro bucket corresponde ao bucket de origem para o qual você enviará as imagens. O segundo bucket é usado pelo Lambda para salvar a miniatura redimensionada quando você invoca a função.
------
#### [ Console de gerenciamento da AWS ]
**Criar os buckets do Amazon S3 (console)**
1. Abra o [console do Amazon S3](https://console.aws.amazon.com/s3) e selecione a página **Buckets de uso geral**.
1. Selecione a Região da AWS mais próxima de sua localização geográfica. É possível alterar a região usando a lista suspensa na parte superior da tela. Mais adiante no tutorial, você deverá criar sua função do Lambda na mesma região.
![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/console_region_select.png)
1. Selecione **Criar bucket**.
1. Em **General configuration** (Configuração geral), faça o seguinte:
1. Em **Tipo de bucket**, certifique-se de que **Uso geral** esteja selecionado.
1. Em **Nome do bucket**, insira um nome global exclusivo que atenda às [regras de nomenclatura de buckets](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucketnamingrules.html) do Amazon S3. Os nomes dos buckets podem conter apenas letras minúsculas, números, pontos (.) e hifens (-).
1. Deixe todas as outras opções com seus valores padrão e escolha **Criar bucket**.
1. Repita as etapas 1 a 5 para criar o bucket de destino. Em **Nome do bucket**, insira `amzn-s3-demo-source-bucket-resized`, em que `amzn-s3-demo-source-bucket` corresponde ao nome do bucket de origem que você acabou de criar.
------
#### [ AWS CLI ]
**Criar os buckets do Amazon S3 (AWS CLI)**
1. Execute o comando da CLI apresentado a seguir para criar o bucket de origem. O nome escolhido para o bucket deve ser globalmente exclusivo e seguir as [Regras de nomeação de bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucketnamingrules.html) para o Amazon S3. Os nomes podem conter somente letras minúsculas, números, pontos (.) e hifens (-). Em `region` e `LocationConstraint`, escolha a [Região da AWS](https://docs.aws.amazon.com/general/latest/gr/lambda-service.html) mais próxima de sua localização geográfica.
```
aws s3api create-bucket --bucket amzn-s3-demo-source-bucket --region us-east-1 \
--create-bucket-configuration LocationConstraint=us-east-1
```
Posteriormente no tutorial, você deverá criar a função do Lambda na mesma Região da AWS em que o bucket de origem foi criado, portanto, anote a região escolhida.
1. Execute o comando apresentado a seguir para criar o bucket de destino. Para o nome do bucket, você deve usar `amzn-s3-demo-source-bucket-resized`, em que `amzn-s3-demo-source-bucket` é o nome do bucket de origem criado na etapa 1. Em `region` e `LocationConstraint`, escolha a mesma Região da AWS que você usou ao criar o bucket de origem.
```
aws s3api create-bucket --bucket amzn-s3-demo-source-bucket-resized --region us-east-1 \
--create-bucket-configuration LocationConstraint=us-east-1
```
------
## Faça upload de uma imagem de teste para o bucket de origem
![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_steps2.png)
Posteriormente no tutorial, você testará a função do Lambda ao invocá-la usando a AWS CLI ou o console do Lambda. Para confirmar que a função está funcionando corretamente, o bucket de origem precisa conter uma imagem de teste. Essa imagem pode ser qualquer arquivo JPG ou PNG que você escolher.
------
#### [ Console de gerenciamento da AWS ]
**Fazer upload de uma imagem de teste para o bucket de origem (console)**
1. Abra a página [Buckets](https://console.aws.amazon.com/s3/buckets) do console do Amazon S3.
1. Selecione o bucket de origem criado na etapa anterior.
1. Escolha **Carregar**.
1. Escolha **Adicionar arquivos** e use o seletor de arquivos para escolher o objeto que você deseja carregar.
1. Selecione **Abrir** e **Carregar**.
------
#### [ AWS CLI ]
**Fazer upload de uma imagem de teste para o bucket de origem (AWS CLI)**
+ No diretório que contém a imagem que você deseja fazer upload, execute o comando da CLI apresentado a seguir. Substitua o parâmetro `--bucket` pelo nome do bucket de origem. Para os parâmetros `--key` e `--body`, use o nome de arquivo da imagem de teste.
```
aws s3api put-object --bucket amzn-s3-demo-source-bucket --key HappyFace.jpg --body ./HappyFace.jpg
```
------
## Criação de uma política de permissões
![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_steps3.png)
A primeira etapa na criação da função do Lambda é criar uma política de permissões. Essa política concede à sua função as permissões necessárias para acessar outros recursos da AWS. Para este tutorial, a política concede ao Lambda permissões de leitura e gravação para buckets do Amazon S3 e permite que ele grave no Amazon CloudWatch Logs.
------
#### [ Console de gerenciamento da AWS ]
**Criar a política (console)**
1. Abra a [página Policies](https://console.aws.amazon.com/iamv2/home#policies) (Políticas) do console do AWS Identity and Access Management (IAM).
1. Escolha **Criar política**.
1. Escolha a guia **JSON** e cole a política personalizada a seguir no editor JSON.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"logs:PutLogEvents",
"logs:CreateLogGroup",
"logs:CreateLogStream"
],
"Resource": "arn:aws:logs:*:*:*"
},
{
"Effect": "Allow",
"Action": [
"s3:GetObject"
],
"Resource": "arn:aws:s3:::*/*"
},
{
"Effect": "Allow",
"Action": [
"s3:PutObject"
],
"Resource": "arn:aws:s3:::*/*"
}
]
}
```
1. Escolha **Próximo**.
1. No campo **Detalhes da política**, em **Nome da política**, insira `LambdaS3Policy`.
1. Escolha **Criar política**.
------
#### [ AWS CLI ]
**Criar a política (AWS CLI)**
1. Salve o JSON a seguir em um arquivo denominado `policy.json`.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"logs:PutLogEvents",
"logs:CreateLogGroup",
"logs:CreateLogStream"
],
"Resource": "arn:aws:logs:*:*:*"
},
{
"Effect": "Allow",
"Action": [
"s3:GetObject"
],
"Resource": "arn:aws:s3:::*/*"
},
{
"Effect": "Allow",
"Action": [
"s3:PutObject"
],
"Resource": "arn:aws:s3:::*/*"
}
]
}
```
1. No diretório em que você salvou o documento de política JSON, execute o comando da CLI apresentado a seguir.
```
aws iam create-policy --policy-name LambdaS3Policy --policy-document file://policy.json
```
------
## Criar uma função de execução
![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_steps4.png)
Um perfil de execução é um perfil do IAM que concede a uma função do Lambda permissão para acessar os recursos e Serviços da AWS. Para conceder à sua função acesso de leitura e gravação a um bucket do Amazon S3, anexe a política de permissões criada na etapa anterior.
------
#### [ Console de gerenciamento da AWS ]
**Criar um perfil de execução e anexar a política de permissões (console)**
1. Abra a página [Perfis](https://console.aws.amazon.com/iamv2/home#roles) no console do IAM.
1. Escolha **Criar Perfil**.
1. Em **Tipo de entidade confiável**, selecione **AWS service (Serviço da AWS)**, e em **Caso de uso**, selecione **Lambda**.
1. Escolha **Próximo**.
1. Adicione a política de permissões criada na etapa anterior fazendo o seguinte:
1. Na caixa de pesquisa de política, insira `LambdaS3Policy`.
1. Nos resultados da pesquisa, marque a caixa de seleção `LambdaS3Policy`.
1. Escolha **Próximo**.
1. Em **Detalhes do perfil**, em **Nome do perfil**, insira `LambdaS3Role`.
1. Selecione **Criar perfil**.
------
#### [ AWS CLI ]
**Criar um perfil de execução e anexar a política de permissões (AWS CLI)**
1. Salve o JSON a seguir em um arquivo denominado `trust-policy.json`. Essa política de confiança permite que o Lambda use as permissões do perfil ao conceder à entidade principal de serviço a permissão `lambda.amazonaws.com` para chamar a ação `AssumeRole` do AWS Security Token Service (AWS STS).
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
1. No diretório em que você salvou o documento de política de confiança JSON, execute o comando da CLI apresentado a seguir para criar o perfil de execução.
```
aws iam create-role --role-name LambdaS3Role --assume-role-policy-document file://trust-policy.json
```
1. Para anexar a política de permissões criada na etapa anterior, execute o comando da CLI apresentado a seguir. Substitua o número da Conta da AWS no ARN da política pelo número da sua conta.
```
aws iam attach-role-policy --role-name LambdaS3Role --policy-arn arn:aws:iam::123456789012:policy/LambdaS3Policy
```
------
## Crie o pacote de implantação de função
![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_steps5.png)
Para criar sua função, crie um *pacote de implantação* contendo o código de função e as dependências. Para essa função `CreateThumbnail`, o código de função usa uma biblioteca separada para o redimensionamento da imagem. Siga as instruções para a linguagem escolhida para criar um pacote de implantação contendo a biblioteca necessária.
------
#### [ Node.js ]
**Criar o pacote de implantação (Node.js)**
1. Crie um diretório denominado `lambda-s3` para o código de função e as dependências e navegue até ele.
```
mkdir lambda-s3
cd lambda-s3
```
1. Crie um novo projeto Node.js com o `npm`. Para aceitar as opções padrão fornecidas na experiência interativa, pressione `Enter`.
```
npm init
```
1. Salve o código de função apresentado a seguir em um arquivo denominado `index.mjs`. Certifique-se de substituir `us-east-1` pela Região da AWS na qual você criou seus próprios buckets de origem e destino.
```
// dependencies
import { S3Client, GetObjectCommand, PutObjectCommand } from '@aws-sdk/client-s3';
import { Readable } from 'stream';
import sharp from 'sharp';
import util from 'util';
// create S3 client
const s3 = new S3Client({region: 'us-east-1'});
// define the handler function
export const handler = async (event, context) => {
// Read options from the event parameter and get the source bucket
console.log("Reading options from event:\n", util.inspect(event, {depth: 5}));
const srcBucket = event.Records[0].s3.bucket.name;
// Object key may have spaces or unicode non-ASCII characters
const srcKey = decodeURIComponent(event.Records[0].s3.object.key.replace(/\+/g, " "));
const dstBucket = srcBucket + "-resized";
const dstKey = "resized-" + srcKey;
// Infer the image type from the file suffix
const typeMatch = srcKey.match(/\.([^.]*)$/);
if (!typeMatch) {
console.log("Could not determine the image type.");
return;
}
// Check that the image type is supported
const imageType = typeMatch[1].toLowerCase();
if (imageType != "jpg" && imageType != "png") {
console.log(`Unsupported image type: ${imageType}`);
return;
}
// Get the image from the source bucket. GetObjectCommand returns a stream.
try {
const params = {
Bucket: srcBucket,
Key: srcKey
};
var response = await s3.send(new GetObjectCommand(params));
var stream = response.Body;
// Convert stream to buffer to pass to sharp resize function.
if (stream instanceof Readable) {
var content_buffer = Buffer.concat(await stream.toArray());
} else {
throw new Error('Unknown object stream type');
}
} catch (error) {
console.log(error);
return;
}
// set thumbnail width. Resize will set the height automatically to maintain aspect ratio.
const width = 200;
// Use the sharp module to resize the image and save in a buffer.
try {
var output_buffer = await sharp(content_buffer).resize(width).toBuffer();
} catch (error) {
console.log(error);
return;
}
// Upload the thumbnail image to the destination bucket
try {
const destparams = {
Bucket: dstBucket,
Key: dstKey,
Body: output_buffer,
ContentType: "image"
};
const putResult = await s3.send(new PutObjectCommand(destparams));
} catch (error) {
console.log(error);
return;
}
console.log('Successfully resized ' + srcBucket + '/' + srcKey +
' and uploaded to ' + dstBucket + '/' + dstKey);
};
```
1. No diretório `lambda-s3`, instale a biblioteca sharp usando npm. Observe que a versão mais recente do sharp (0.33) não é compatível com o Lambda. Instale a versão 0.32.6 para concluir este tutorial.
```
npm install sharp@0.32.6
```
O comando npm `install` cria um diretório `node_modules` para seus módulos. Após esta etapa, sua estrutura de diretórios deve ser semelhante à apresentada a seguir.
```
lambda-s3
|- index.mjs
|- node_modules
| |- base64js
| |- bl
| |- buffer
...
|- package-lock.json
|- package.json
```
1. Crie um pacote de implantação .zip contendo o código de função e as dependências. No MacOS e Linux, execute o comando apresentado a seguir.
```
zip -r function.zip .
```
No Windows, use o utilitário zip preferencial para criar um arquivo .zip. Certifique-se de que os arquivos `index.mjs`, `package.json` e `package-lock.json` e o diretório `node_modules` estejam todos na raiz do arquivo .zip.
------
#### [ Python ]
**Criar o pacote de implantação (Python)**
1. Salve o exemplo de código como um arquivo denominado `lambda_function.py`.
```
import boto3
import os
import sys
import uuid
from urllib.parse import unquote_plus
from PIL import Image
import PIL.Image
s3_client = boto3.client('s3')
def resize_image(image_path, resized_path):
with Image.open(image_path) as image:
image.thumbnail(tuple(x / 2 for x in image.size))
image.save(resized_path)
def lambda_handler(event, context):
for record in event['Records']:
bucket = record['s3']['bucket']['name']
key = unquote_plus(record['s3']['object']['key'])
tmpkey = key.replace('/', '')
download_path = '/tmp/{}{}'.format(uuid.uuid4(), tmpkey)
upload_path = '/tmp/resized-{}'.format(tmpkey)
s3_client.download_file(bucket, key, download_path)
resize_image(download_path, upload_path)
s3_client.upload_file(upload_path, '{}-resized'.format(bucket), 'resized-{}'.format(key))
```
1. No mesmo diretório em que você criou o arquivo `lambda_function.py`, crie um novo diretório denominado `package` e instale a biblioteca [Pillow (PIL)](https://pypi.org/project/Pillow/) e o AWS SDK para Python (Boto3). Embora o runtime do Python no Lambda inclua uma versão do SDK do Boto3, recomendamos que você adicione todas as dependências da função ao pacote de implantação, mesmo que estejam inclusas no runtime. Para obter mais informações, consulte [Dependências de runtime em Python](https://docs.aws.amazon.com/lambda/latest/dg/python-package.html#python-package-dependencies).
```
mkdir package
pip install \
--platform manylinux2014_x86_64 \
--target=package \
--implementation cp \
--python-version 3.12 \
--only-binary=:all: --upgrade \
pillow boto3
```
A biblioteca Pillow contém código C/C\$1\$1. Usando as opções `--platform manylinux_2014_x86_64` e `--only-binary=:all:`, o pip baixará e instalará uma versão do Pillow que contém binários pré-compilados compatíveis com o sistema operacional Amazon Linux 2. Isso garante que o pacote de implantação funcione no ambiente de execução do Lambda, independentemente do sistema operacional e da arquitetura da máquina de compilação local.
1. Crie um arquivo .zip contendo o código da aplicação e as bibliotecas Pillow e Boto3. No Linux ou no MacOS, execute os comandos a seguir na interface da linha de comando.
```
cd package
zip -r ../lambda_function.zip .
cd ..
zip lambda_function.zip lambda_function.py
```
No Windows, use sua ferramenta de zip preferida para criar o arquivo `lambda_function.zip`. Certifique-se de que o arquivo `lambda_function.py` e as pastas que contêm as dependências estejam todos na raiz do arquivo .zip.
Também é possível criar seu pacote de implantação usando um ambiente virtual Python. Consulte [Trabalhar com arquivos .zip para funções do Lambda em Python](python-package.md)
------
## Criar a função do Lambda
![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_steps6.png)
Você pode criar a função do Lambda usando a AWS CLI ou o console do Lambda. Siga as instruções da linguagem escolhida para criar a função.
------
#### [ Console de gerenciamento da AWS ]
**Para criar a função (console)**
Para criar a função do Lambda usando o console, primeiro é necessário criar uma função básica contendo algum código “Hello world”. Em seguida, substitua esse código pelo seu código de função ao fazer upload do arquivo.zip ou JAR criado na etapa anterior.
1. Abra a [página Funções](https://console.aws.amazon.com/lambda/home#/functions) do console do Lambda.
1. Verifique se você está trabalhando na mesma Região da AWS em que criou o bucket do Amazon S3. É possível alterar a região usando a lista suspensa na parte superior da tela.
![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/console_region_select.png)
1. Escolha **Create function** (Criar função).
1. Escolha **Author from scratch** (Criar do zero).
1. Em **Basic information** (Informações básicas), faça o seguinte:
1. Em **Function name** (Nome da função), insira `CreateThumbnail`.
1. Em **Runtime**, escolha **Node.js 22.x** ou **Python 3.12** de acordo com a linguagem que você escolheu para a função.
1. Em **Architecture** (Arquitetura), escolha **x86\$164**.
1. Na guia **Alterar função de execução padrão**, faça o seguinte:
1. Expanda a guia e escolha **Usar uma função existente**.
1. Selecione a `LambdaS3Role` que você criou anteriormente.
1. Escolha **Criar função**.
**Fazer upload do código da função (console)**
1. No painel do **Código-fonte**, escolha **Carregar de**.
1. Escolha o **arquivo .zip**.
1. Escolha **Carregar**.
1. No seletor de arquivos, selecione o arquivo .zip e escolha **Abrir**.
1. Escolha **Salvar**.
------
#### [ AWS CLI ]
**Criar a função (AWS CLI)**
+ Execute o comando da CLI para a linguagem escolhida. Para o parâmetro `role`, certifique-se de substituir `123456789012` por seu ID da Conta da AWS. Para o parâmetro `region`, substitua `us-east-1` pela região em que você criou os buckets do Amazon S3.
+ Para **Node.js**, execute o comando a seguir no diretório que contém o arquivo `function.zip`.
```
aws lambda create-function --function-name CreateThumbnail \
--zip-file fileb://function.zip --handler index.handler --runtime nodejs24.x \
--timeout 10 --memory-size 1024 \
--role arn:aws:iam::123456789012:role/LambdaS3Role --region us-east-1
```
+ Para **Python**, execute o comando a seguir no diretório que contém o arquivo `lambda_function.zip`.
```
aws lambda create-function --function-name CreateThumbnail \
--zip-file fileb://lambda_function.zip --handler lambda_function.lambda_handler \
--runtime python3.14 --timeout 10 --memory-size 1024 \
--role arn:aws:iam::123456789012:role/LambdaS3Role --region us-east-1
```
------
## Configure o Amazon S3 para invocar a função
![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_steps7.png)
Para que a função do Lambda seja executada quando você faz upload de uma imagem no bucket de origem, é necessário configurar um acionador para a função. Você pode configurar o acionador do Amazon S3 usando o console ou a AWS CLI.
**Importante**
Este procedimento configura o bucket do Amazon S3 para invocar a função toda vez que um objeto é criado no bucket. Certifique-se de configurar isso somente no bucket de origem. Se a função do Lambda criar objetos no mesmo bucket que a invoca, a função poderá ser [invocada continuamente em um loop](https://serverlessland.com/content/service/lambda/guides/aws-lambda-operator-guide/recursive-runaway). Isso pode resultar em cobranças inesperadas para sua Conta da AWS.
------
#### [ Console de gerenciamento da AWS ]
**Configurar o acionador do Amazon S3 (console)**
1. Abra a [página de Funções](https://console.aws.amazon.com/lambda/home#/functions) do console do Lambda e escolha sua função (`CreateThumbnail`).
1. Escolha **Add trigger**.
1. Selecione **S3**.
1. Em **Bucket**, selecione o bucket de origem.
1. Em **Tipos de eventos**, selecione **Todos os eventos de criação de objetos**.
1. Em **Invocação recursiva**, marque a caixa de seleção para confirmar que não é recomendável usar o mesmo bucket do Amazon S3 para entrada e saída. Saiba mais sobre padrões de invocação recursiva no Lambda lendo [Recursive patterns that cause run-away Lambda functions](https://serverlessland.com/content/service/lambda/guides/aws-lambda-operator-guide/recursive-runaway) no Serverless Land.
1. Escolha **Adicionar**.
Quando você cria um acionador usando o console do Lambda, o Lambda cria automaticamente uma [política baseada em recursos](https://docs.aws.amazon.com/lambda/latest/dg/access-control-resource-based.html) para conceder permissão ao serviço selecionado para invocar a função.
------
#### [ AWS CLI ]
**Configurar o acionador do Amazon S3 (AWS CLI)**
1. Para que o bucket de origem do Amazon S3 invoque a função ao adicionar um arquivo de imagem, primeiro é necessário configurar permissões para a função usando uma [política baseada em recursos](https://docs.aws.amazon.com/lambda/latest/dg/access-control-resource-based.html). Uma instrução de política baseada em recursos concede permissão a outros Serviços da AWS para invocar sua função. Para conceder permissão ao Amazon S3 para invocar a função, execute o comando da CLI apresentado a seguir. Certifique-se de substituir o parâmetro `source-account` por seu ID da Conta da AWS e usar o nome do bucket de origem.
```
aws lambda add-permission --function-name CreateThumbnail \
--principal s3.amazonaws.com --statement-id s3invoke --action "lambda:InvokeFunction" \
--source-arn arn:aws:s3:::amzn-s3-demo-source-bucket \
--source-account 123456789012
```
A política que você define com este comando permite que o Amazon S3 invoque a função somente quando uma ação ocorre em seu bucket de origem.
**nota**
Embora os nomes de bucket do Amazon S3 sejam globalmente exclusivos, ao usar políticas baseadas em recursos, é uma prática recomendada especificar que o bucket deve pertencer à sua conta. Isso ocorre porque, se você excluir um bucket, é possível que outra Conta da AWS crie um bucket com o mesmo nome do recurso da Amazon (ARN).
1. Salve o JSON a seguir em um arquivo denominado `notification.json`. Quando aplicado ao bucket de origem, esse JSON configura o bucket para enviar uma notificação à sua função do Lambda sempre que um novo objeto é adicionado. Substitua o número da Conta da AWS e a Região da AWS no ARN da função do Lambda por seu número de conta e sua região.
```
{
"LambdaFunctionConfigurations": [
{
"Id": "CreateThumbnailEventConfiguration",
"LambdaFunctionArn": "arn:aws:lambda:us-east-1:123456789012:function:CreateThumbnail",
"Events": [ "s3:ObjectCreated:Put" ]
}
]
}
```
1. Execute o comando da CLI apresentado a seguir para aplicar as configurações de notificação no arquivo JSON criado ao bucket de origem. Substitua `amzn-s3-demo-source-bucket` pelo nome do bucket de origem.
```
aws s3api put-bucket-notification-configuration --bucket amzn-s3-demo-source-bucket \
--notification-configuration file://notification.json
```
Para saber mais sobre o comando `put-bucket-notification-configuration` e a opção `notification-configuration`, consulte [put-bucket-notification-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/put-bucket-notification-configuration.html) na *Referência de comandos da CLI da AWS*.
------
## Testar sua função do Lambda com um evento fictício
![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_steps8.png)
Antes de testar toda a configuração ao adicionar um arquivo de imagem ao bucket de origem do Amazon S3, teste se a função do Lambda está funcionando corretamente ao invocá-la com um evento fictício. Um evento no Lambda corresponde a um documento formatado em JSON que contém dados para sua função processar. Quando a função é invocada pelo Amazon S3, o evento enviado para a função contém informações como o nome do bucket, o ARN do bucket e a chave do objeto.
------
#### [ Console de gerenciamento da AWS ]
**Testar a função do Lambda com um evento fictício (console)**
1. Abra a [página de Funções](https://console.aws.amazon.com/lambda/home#/functions) do console do Lambda e escolha sua função (`CreateThumbnail`).
1. Selecione a guia **Testar**.
1. Para criar o evento de teste, no painel **Evento de teste**, faça o seguinte:
1. Em **Ação de evento de teste**, selecione **Criar novo evento**.
1. Em **Nome do evento**, insira **myTestEvent**.
1. Em **Modelo**, selecione **S3 Put**.
1. Substitua os valores dos parâmetros apresentados a seguir por seus valores.
+ Em `awsRegion`, substitua `us-east-1` pela Região da AWS em que você criou os buckets do Amazon S3.
+ Em `name`, substitua `amzn-s3-demo-bucket` pelo nome do bucket de origem do Amazon S3.
+ Em `key`, substitua `test%2Fkey` pelo nome do arquivo do objeto de teste que você fez upload no bucket de origem na etapa [Faça upload de uma imagem de teste para o bucket de origem](#with-s3-tutorial-test-image).
```
{
"Records": [
{
"eventVersion": "2.0",
"eventSource": "aws:s3",
"awsRegion": "us-east-1",
"eventTime": "1970-01-01T00:00:00.000Z",
"eventName": "ObjectCreated:Put",
"userIdentity": {
"principalId": "EXAMPLE"
},
"requestParameters": {
"sourceIPAddress": "127.0.0.1"
},
"responseElements": {
"x-amz-request-id": "EXAMPLE123456789",
"x-amz-id-2": "EXAMPLE123/5678abcdefghijklambdaisawesome/mnopqrstuvwxyzABCDEFGH"
},
"s3": {
"s3SchemaVersion": "1.0",
"configurationId": "testConfigRule",
"bucket": {
"name": "amzn-s3-demo-bucket",
"ownerIdentity": {
"principalId": "EXAMPLE"
},
"arn": "arn:aws:s3:::amzn-s3-demo-bucket"
},
"object": {
"key": "test%2Fkey",
"size": 1024,
"eTag": "0123456789abcdef0123456789abcdef",
"sequencer": "0A1B2C3D4E5F678901"
}
}
}
]
}
```
1. Escolha **Salvar**.
1. No painel **Evento de teste**, escolha **Testar**.
1. Para verificar se a função criou uma versão redimensionada da imagem e a armazenou em seu bucket de destino do Amazon S3, faça o seguinte:
1. Abra a [página Buckets](https://console.aws.amazon.com/s3/buckets) do console do Amazon S3.
1. Escolha o bucket de destino e confirme se o arquivo redimensionado está listado no painel **Objetos**.
------
#### [ AWS CLI ]
**Testar a função do Lambda com um evento fictício (AWS CLI)**
1. Salve o JSON a seguir em um arquivo denominado `dummyS3Event.json`. Substitua os valores dos seguintes parâmetros por seus valores:
+ Em `awsRegion`, substitua `us-east-1` pela Região da AWS em que você criou os buckets do Amazon S3.
+ Em `name`, substitua `amzn-s3-demo-bucket` pelo nome do bucket de origem do Amazon S3.
+ Em `key`, substitua `test%2Fkey` pelo nome do arquivo do objeto de teste que você fez upload no bucket de origem na etapa [Faça upload de uma imagem de teste para o bucket de origem](#with-s3-tutorial-test-image).
```
{
"Records": [
{
"eventVersion": "2.0",
"eventSource": "aws:s3",
"awsRegion": "us-east-1",
"eventTime": "1970-01-01T00:00:00.000Z",
"eventName": "ObjectCreated:Put",
"userIdentity": {
"principalId": "EXAMPLE"
},
"requestParameters": {
"sourceIPAddress": "127.0.0.1"
},
"responseElements": {
"x-amz-request-id": "EXAMPLE123456789",
"x-amz-id-2": "EXAMPLE123/5678abcdefghijklambdaisawesome/mnopqrstuvwxyzABCDEFGH"
},
"s3": {
"s3SchemaVersion": "1.0",
"configurationId": "testConfigRule",
"bucket": {
"name": "amzn-s3-demo-bucket",
"ownerIdentity": {
"principalId": "EXAMPLE"
},
"arn": "arn:aws:s3:::amzn-s3-demo-bucket"
},
"object": {
"key": "test%2Fkey",
"size": 1024,
"eTag": "0123456789abcdef0123456789abcdef",
"sequencer": "0A1B2C3D4E5F678901"
}
}
}
]
}
```
1. No diretório em que você salvou o arquivo `dummyS3Event.json`, invoque a função ao executar o comando da CLI apresentado a seguir. Esse comando invoca a função do Lambda de forma síncrona ao especificar `RequestResponse` como o valor do parâmetro para o tipo de invocação. Para saber mais sobre invocação assíncrona e síncrona, consulte [Chamada de funções do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-invocation.html).
```
aws lambda invoke --function-name CreateThumbnail \
--invocation-type RequestResponse --cli-binary-format raw-in-base64-out \
--payload file://dummyS3Event.json outputfile.txt
```
A opção cli-binary-format será necessária se você estiver usando a versão 2 da AWS CLI. Para que essa seja a configuração padrão, execute `aws configure set cli-binary-format raw-in-base64-out`. Para obter mais informações, consulte [Opções de linhas de comando globais compatíveis com a AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list).
1. Verifique se a função criou uma versão em miniatura da imagem e a salvou no bucket de destino do Amazon S3. Execute o comando da CLI apresentado a seguir, substituindo `amzn-s3-demo-source-bucket-resized` pelo nome do bucket de destino.
```
aws s3api list-objects-v2 --bucket amzn-s3-demo-source-bucket-resized
```
Você deve ver saída semelhante ao seguinte: O parâmetro `Key` mostra o nome do arquivo de imagem redimensionado.
```
{
"Contents": [
{
"Key": "resized-HappyFace.jpg",
"LastModified": "2023-06-06T21:40:07+00:00",
"ETag": "\"d8ca652ffe83ba6b721ffc20d9d7174a\"",
"Size": 2633,
"StorageClass": "STANDARD"
}
]
}
```
------
## Teste a função usando o acionador do Amazon S3
![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_steps9.png)
Agora que você confirmou que a função do Lambda está funcionando corretamente, você está com tudo pronto para testar a configuração completa ao adicionar um arquivo de imagem ao bucket de origem do Amazon S3. Quando você adiciona a imagem ao bucket de origem, a função do Lambda deve ser invocada automaticamente. A função cria uma versão redimensionada do arquivo e a armazena no bucket de destino.
------
#### [ Console de gerenciamento da AWS ]
**Testar a função do Lambda usando o acionador do Amazon S3 (console)**
1. Para fazer upload de uma imagem para o bucket do Amazon S3, faça o seguinte:
1. Abra a página [Buckets](https://console.aws.amazon.com/s3/buckets) do console do Amazon S3 e escolha o bucket de origem.
1. Escolha **Carregar**.
1. Escolha **Adicionar arquivos** e use o seletor de arquivo para escolher o arquivo de imagem que deseja carregar. O objeto de imagem pode ser qualquer arquivo .jpg ou .png.
1. Selecione **Abrir** e **Carregar**.
1. Verifique se o Lambda salvou uma versão redimensionada do arquivo de imagem no bucket de destino fazendo o seguinte:
1. Retorne para a página [Buckets](https://console.aws.amazon.com/s3/buckets) do console do Amazon S3 e escolha o bucket de destino.
1. No painel **Objetos**, deve ser possível visualizar dois arquivos de imagem redimensionados, sendo um de cada teste da função do Lambda. Para baixar a imagem redimensionada, selecione o arquivo e escolha **Fazer download**.
------
#### [ AWS CLI ]
**Testar a função do Lambda usando o acionador do Amazon S3 (AWS CLI)**
1. No diretório que contém a imagem que você deseja fazer upload, execute o comando da CLI apresentado a seguir. Substitua o parâmetro `--bucket` pelo nome do bucket de origem. Para os parâmetros `--key` e `--body`, use o nome de arquivo da imagem de teste. A imagem de teste pode ser qualquer arquivo .jpg ou .png.
```
aws s3api put-object --bucket amzn-s3-demo-source-bucket --key SmileyFace.jpg --body ./SmileyFace.jpg
```
1. Verifique se a função criou uma versão em miniatura da imagem e a salvou no bucket de destino do Amazon S3. Execute o comando da CLI apresentado a seguir, substituindo `amzn-s3-demo-source-bucket-resized` pelo nome do bucket de destino.
```
aws s3api list-objects-v2 --bucket amzn-s3-demo-source-bucket-resized
```
Se a função for executada com êxito, você visualizará uma saída semelhante à apresentada a seguir. Agora, o bucket de destino deve conter dois arquivos redimensionados.
```
{
"Contents": [
{
"Key": "resized-HappyFace.jpg",
"LastModified": "2023-06-07T00:15:50+00:00",
"ETag": "\"7781a43e765a8301713f533d70968a1e\"",
"Size": 2763,
"StorageClass": "STANDARD"
},
{
"Key": "resized-SmileyFace.jpg",
"LastModified": "2023-06-07T00:13:18+00:00",
"ETag": "\"ca536e5a1b9e32b22cd549e18792cdbc\"",
"Size": 1245,
"StorageClass": "STANDARD"
}
]
}
```
------
## Limpe os recursos
Agora você pode excluir os recursos criados para este tutorial, a menos que queira mantê-los. Excluindo os recursos da AWS que você não está mais usando, você evita cobranças desnecessárias em sua Conta da AWS.
**Como excluir a função do Lambda**
1. Abra a página [Functions](https://console.aws.amazon.com/lambda/home#/functions) (Funções) no console do Lambda.
1. Selecione a função que você criou.
1. Selecione **Ações**, **Excluir**.
1. Digite **confirm** no campo de entrada de texto e escolha **Delete** (Excluir).
**Para excluir a política que você criou**
1. Abra a [página Policies](https://console.aws.amazon.com/iam/home#/policies) (Políticas) do console do IAM.
1. Selecione a política que você criou (**AWSLambdaS3Policy**).
1. Escolha **Policy actions** (Ações de política) e **Delete** (Excluir).
1. Escolha **Excluir**.
**Para excluir a função de execução**
1. Abra a página [Roles](https://console.aws.amazon.com/iam/home#/roles) (Funções) no console do IAM.
1. Selecione a função de execução que você criou.
1. Escolha **Excluir**.
1. Insira o nome do perfil no campo de entrada de texto e escolha **Delete** (Excluir).
**Para excluir o bucket do S3**
1. Abra o [console Amazon S3](https://console.aws.amazon.com//s3/home#).
1. Selecione o bucket que você criou.
1. Escolha **Excluir**.
1. Insira o nome do bucket no campo de entrada de texto.
1. Escolha **Excluir bucket**.