# Processar notificações de eventos do Amazon S3 com o Lambda
Você pode usar o Lambda para processar [notificações de eventos](https://docs.aws.amazon.com/AmazonS3/latest/userguide/NotificationHowTo.html) do Amazon Simple Storage Service. O Amazon S3 pode enviar um evento para uma função do Lambda quando um objeto é criado ou excluído. Você define as configurações de notificação em um bucket e concede permissão ao Amazon S3 para invocar uma função na política de permissões baseada em recursos da função.
**Atenção**
Se a função do Lambda usar o mesmo bucket que a aciona, isso poderá fazer a função ser executada em um loop. Por exemplo, se o bucket disparar uma função sempre que um objeto for carregado e a função fizer upload de um objeto no bucket, a função vai se disparar indiretamente. Para evitar isso, use dois buckets ou configure o trigger para só se aplicar a um prefixo usado em objetos recebidos.
O Amazon S3 invoca a função [de forma assíncrona](invocation-async.md) com um evento que contém detalhes sobre o objeto. O exemplo a seguir mostra um evento que o Amazon S3 enviou quando um pacote de implantação foi carregado no Amazon S3.
**Example Evento de notificação do Amazon S3**
```
{
"Records": [
{
"eventVersion": "2.1",
"eventSource": "aws:s3",
"awsRegion": "us-east-2",
"eventTime": "2019-09-03T19:37:27.192Z",
"eventName": "ObjectCreated:Put",
"userIdentity": {
"principalId": "AWS:AIDAINPONIXQXHT3IKHL2"
},
"requestParameters": {
"sourceIPAddress": "205.255.255.255"
},
"responseElements": {
"x-amz-request-id": "D82B88E5F771F645",
"x-amz-id-2": "vlR7PnpV2Ce81l0PRw6jlUpck7Jo5ZsQjryTjKlc5aLWGVHPZLj5NeC6qMa0emYBDXOo6QBU0Wo="
},
"s3": {
"s3SchemaVersion": "1.0",
"configurationId": "828aa6fc-f7b5-4305-8584-487c791949c1",
"bucket": {
"name": "amzn-s3-demo-bucket",
"ownerIdentity": {
"principalId": "A3I5XTEXAMAI3E"
},
"arn": "arn:aws:s3:::lambda-artifacts-deafc19498e3f2df"
},
"object": {
"key": "b21b84d653bb07b05b1e6b33684dc11b",
"size": 1305107,
"eTag": "b21b84d653bb07b05b1e6b33684dc11b",
"sequencer": "0C0F6F405D6ED209E1"
}
}
}
]
}
```
Para invocar a função, o Amazon S3 precisa de permissão da [política baseada em recursos](access-control-resource-based.md) da função. Quando você configura um acionador do Amazon S3 no console do Lambda, o console modifica a política baseada em recursos para permitir que o Amazon S3 invoque a função se o nome do bucket e o ID da conta corresponderem. Se você configurar a notificação no Amazon S3, use a API do lambda para atualizar a política. Também é possível usar a API do Lambda para conceder permissão a outra conta ou restringir a permissão a um alias designado.
Se a sua função usa o AWS SDK para gerenciar recursos do Amazon S3, ela também precisa de permissões do Amazon S3 em sua [função de execução](lambda-intro-execution-role.md).
**Topics**
+ [
# Tutorial: Usar um acionador do Amazon S3 para invocar uma função do Lambda
](with-s3-example.md)
+ [
# Tutorial: Usar um acionador do Amazon S3 para criar imagens em miniatura
](with-s3-tutorial.md)
# Tutorial: Usar um acionador do Amazon S3 para invocar uma função do Lambda
Neste tutorial, você usará o console para criar uma função do Lambda e configurar um acionador para um bucket do Amazon Simple Storage Service (Amazon S3). Toda vez que você adiciona um objeto ao bucket do Amazon S3, sua função é executada e envia o tipo de objeto ao Amazon CloudWatch Logs.
![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/services-s3-example/s3_tut_config.png)
Este tutorial demonstra como:
1. Crie um bucket do Amazon S3.
1. Crie uma função do Lambda que retorne o tipo de objeto de um bucket do Amazon S3.
1. Configure um acionador do Lambda que invoque a função quando forem carregados objetos para o bucket.
1. Teste sua função, primeiro com um evento fictício e depois usando o acionador.
Ao concluir essas etapas, você aprenderá a configurar uma função do Lambda a ser executada sempre que forem adicionados ou excluídos objetos de um bucket do Amazon S3. Você pode concluir este tutorial usando somente o Console de gerenciamento da AWS.
## Criar um bucket do Amazon S3
![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/services-s3-example/s3trigger_tut_steps1.png)
**Como criar um bucket do Amazon S3**
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**.
## Carregar um objeto de teste em um bucket
![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/services-s3-example/s3trigger_tut_steps2.png)
**Para carregar um objeto de teste**
1. Abra a página [Buckets](https://console.aws.amazon.com/s3/buckets) do console do Amazon S3 e escolha o bucket que você criou durante a etapa anterior.
1. Escolha **Carregar**.
1. Escolha **Adicionar arquivos** e selecione o objeto que deseja de carregar. Você pode selecionar qualquer arquivo (por exemplo, `HappyFace.jpg`).
1. Selecione **Abrir** e **Carregar**.
Posteriormente no tutorial, você testará a função do Lambda usando esse objeto.
## Criação de uma política de permissões
![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/services-s3-example/s3trigger_tut_steps3.png)
Crie uma política de permissões que permita ao Lambda obter objetos de um bucket do Amazon S3 e gravar no Amazon CloudWatch Logs.
**Para criar a política**
1. Abra a [página Policies](https://console.aws.amazon.com/iam/home#/policies) (Políticas) do console do IAM.
1. Escolha **Create Policy**.
1. Escolha a guia **JSON** e cole a política personalizada a seguir no editor JSON.
------
#### [ 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:::*/*"
}
]
}
```
------
1. Escolha **Próximo: tags**.
1. Selecione **Próximo: revisar**.
1. No campo **Política de revisão**, em **Nome** da política, insira **s3-trigger-tutorial**.
1. Escolha **Criar política**.
## Criar uma função de execução
![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/services-s3-example/s3trigger_tut_steps4.png)
Um [perfil de execução](lambda-intro-execution-role.md) é um perfil do AWS Identity and Access Management (IAM) que concede a uma função do Lambda permissão para acessar recursos e Serviços da AWS. Nesta etapa, crie um perfil de execução usando a política de permissões que criou na etapa anterior.
**Para criar uma função de execução e vincular a política de permissões personalizada**
1. Abra a página [Funções](https://console.aws.amazon.com/iam/home#/roles) no console do IAM.
1. Selecione **Criar perfil**.
1. Para o tipo de entidade confiável, escolha **Serviço da AWS** e, em seguida, para o caso de uso, selecione **Lambda**.
1. Escolha **Próximo**.
1. Na caixa de pesquisa de política, insira **s3-trigger-tutorial**.
1. Nos resultados da pesquisa, selecione a política que você criou (`s3-trigger-tutorial`) e, depois, escolha **Next** (Avançar).
1. Em **Role details** (Detalhes do perfil), para **Role name** (Nome do perfil), insira **lambda-s3-trigger-role** e, em seguida, escolha **Create role** (Criar perfil).
## Criar a função do Lambda
![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/services-s3-example/s3trigger_tut_steps5.png)
Crie uma função do Lambda no console usando o runtime do Python 3.14.
**Para criar a função do Lambda**
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. Você pode alterar sua 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 a opção **Criar função**.
1. Escolher **Criar do zero**
1. Em **Basic information** (Informações básicas), faça o seguinte:
1. Em **Nome da função**, inserir `s3-trigger-tutorial`
1. Em **Runtime**, selecione **Python 3.14**.
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 `lambda-s3-trigger-role` que você criou anteriormente.
1. Escolha **Criar função**.
## Implantar o código da função
![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/services-s3-example/s3trigger_tut_steps6.png)
Este tutorial usa o runtime do Python 3.14, mas também fornecemos exemplos de arquivos de código para outros runtimes. É possível selecionar a guia na caixa a seguir para ver o código do runtime do seu interesse.
A função do Lambda vai recuperar o nome da chave do objeto carregado e o nome do bucket do parâmetro `event` que receberá do Amazon S3. Em seguida, a função usará o método [get\$1object](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/s3/client/get_object.html) do AWS SDK para Python (Boto3) para recuperar os metadados do objeto, incluindo o tipo de conteúdo (tipo MIME) do objeto carregado.
**Para implantar o código da função**
1. Escolha a guia **Python** na caixa a seguir e copie o código.
------
#### [ .NET ]
**SDK para .NET**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no repositório dos [Exemplos sem servidor](https://github.com/aws-samples/serverless-snippets/tree/main/integration-s3-to-lambda).
Consumir um evento do S3 com o Lambda usando .NET.
```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
using System.Threading.Tasks;
using Amazon.Lambda.Core;
using Amazon.S3;
using System;
using Amazon.Lambda.S3Events;
using System.Web;
// Assembly attribute to enable the Lambda function's JSON input to be converted into a .NET class.
[assembly: LambdaSerializer(typeof(Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer))]
namespace S3Integration
{
public class Function
{
private static AmazonS3Client _s3Client;
public Function() : this(null)
{
}
internal Function(AmazonS3Client s3Client)
{
_s3Client = s3Client ?? new AmazonS3Client();
}
public async Task Handler(S3Event evt, ILambdaContext context)
{
try
{
if (evt.Records.Count <= 0)
{
context.Logger.LogLine("Empty S3 Event received");
return string.Empty;
}
var bucket = evt.Records[0].S3.Bucket.Name;
var key = HttpUtility.UrlDecode(evt.Records[0].S3.Object.Key);
context.Logger.LogLine($"Request is for {bucket} and {key}");
var objectResult = await _s3Client.GetObjectAsync(bucket, key);
context.Logger.LogLine($"Returning {objectResult.Key}");
return objectResult.Key;
}
catch (Exception e)
{
context.Logger.LogLine($"Error processing request - {e.Message}");
return string.Empty;
}
}
}
}
```
------
#### [ Go ]
**SDK para Go V2**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no repositório dos [Exemplos sem servidor](https://github.com/aws-samples/serverless-snippets/tree/main/integration-s3-to-lambda).
Consumir um evento do S3 com o Lambda usando Go.
```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package main
import (
"context"
"log"
"github.com/aws/aws-lambda-go/events"
"github.com/aws/aws-lambda-go/lambda"
"github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/aws-sdk-go-v2/service/s3"
)
func handler(ctx context.Context, s3Event events.S3Event) error {
sdkConfig, err := config.LoadDefaultConfig(ctx)
if err != nil {
log.Printf("failed to load default config: %s", err)
return err
}
s3Client := s3.NewFromConfig(sdkConfig)
for _, record := range s3Event.Records {
bucket := record.S3.Bucket.Name
key := record.S3.Object.URLDecodedKey
headOutput, err := s3Client.HeadObject(ctx, &s3.HeadObjectInput{
Bucket: &bucket,
Key: &key,
})
if err != nil {
log.Printf("error getting head of object %s/%s: %s", bucket, key, err)
return err
}
log.Printf("successfully retrieved %s/%s of type %s", bucket, key, *headOutput.ContentType)
}
return nil
}
func main() {
lambda.Start(handler)
}
```
------
#### [ Java ]
**SDK para Java 2.x**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no repositório dos [Exemplos sem servidor](https://github.com/aws-samples/serverless-snippets/tree/main/integration-s3-to-lambda).
Consumir um evento do S3 com o Lambda usando Java.
```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package example;
import software.amazon.awssdk.services.s3.model.HeadObjectRequest;
import software.amazon.awssdk.services.s3.model.HeadObjectResponse;
import software.amazon.awssdk.services.s3.S3Client;
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import com.amazonaws.services.lambda.runtime.events.S3Event;
import com.amazonaws.services.lambda.runtime.events.models.s3.S3EventNotification.S3EventNotificationRecord;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class Handler implements RequestHandler {
private static final Logger logger = LoggerFactory.getLogger(Handler.class);
@Override
public String handleRequest(S3Event s3event, Context context) {
try {
S3EventNotificationRecord record = s3event.getRecords().get(0);
String srcBucket = record.getS3().getBucket().getName();
String srcKey = record.getS3().getObject().getUrlDecodedKey();
S3Client s3Client = S3Client.builder().build();
HeadObjectResponse headObject = getHeadObject(s3Client, srcBucket, srcKey);
logger.info("Successfully retrieved " + srcBucket + "/" + srcKey + " of type " + headObject.contentType());
return "Ok";
} catch (Exception e) {
throw new RuntimeException(e);
}
}
private HeadObjectResponse getHeadObject(S3Client s3Client, String bucket, String key) {
HeadObjectRequest headObjectRequest = HeadObjectRequest.builder()
.bucket(bucket)
.key(key)
.build();
return s3Client.headObject(headObjectRequest);
}
}
```
------
#### [ JavaScript ]
**SDK para JavaScript (v3)**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no repositório dos [Exemplos sem servidor](https://github.com/aws-samples/serverless-snippets/tree/main/integration-s3-to-lambda).
Consumir um evento do S3 com o Lambda usando JavaScript.
```
import { S3Client, HeadObjectCommand } from "@aws-sdk/client-s3";
const client = new S3Client();
export const handler = async (event, context) => {
// Get the object from the event and show its content type
const bucket = event.Records[0].s3.bucket.name;
const key = decodeURIComponent(event.Records[0].s3.object.key.replace(/\+/g, ' '));
try {
const { ContentType } = await client.send(new HeadObjectCommand({
Bucket: bucket,
Key: key,
}));
console.log('CONTENT TYPE:', ContentType);
return ContentType;
} catch (err) {
console.log(err);
const message = `Error getting object ${key} from bucket ${bucket}. Make sure they exist and your bucket is in the same region as this function.`;
console.log(message);
throw new Error(message);
}
};
```
Consumir um evento do S3 com o Lambda usando TypeScript.
```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
import { S3Event } from 'aws-lambda';
import { S3Client, HeadObjectCommand } from '@aws-sdk/client-s3';
const s3 = new S3Client({ region: process.env.AWS_REGION });
export const handler = async (event: S3Event): Promise => {
// Get the object from the event and show its content type
const bucket = event.Records[0].s3.bucket.name;
const key = decodeURIComponent(event.Records[0].s3.object.key.replace(/\+/g, ' '));
const params = {
Bucket: bucket,
Key: key,
};
try {
const { ContentType } = await s3.send(new HeadObjectCommand(params));
console.log('CONTENT TYPE:', ContentType);
return ContentType;
} catch (err) {
console.log(err);
const message = `Error getting object ${key} from bucket ${bucket}. Make sure they exist and your bucket is in the same region as this function.`;
console.log(message);
throw new Error(message);
}
};
```
------
#### [ PHP ]
**SDK para PHP**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no repositório dos [Exemplos sem servidor](https://github.com/aws-samples/serverless-snippets/tree/main/integration-s3-to-lambda).
Como consumir um evento do S3 com o Lambda usando PHP.
```
logger = $logger;
}
public function handleS3(S3Event $event, Context $context) : void
{
$this->logger->info("Processing S3 records");
// Get the object from the event and show its content type
$records = $event->getRecords();
foreach ($records as $record)
{
$bucket = $record->getBucket()->getName();
$key = urldecode($record->getObject()->getKey());
try {
$fileSize = urldecode($record->getObject()->getSize());
echo "File Size: " . $fileSize . "\n";
// TODO: Implement your custom processing logic here
} catch (Exception $e) {
echo $e->getMessage() . "\n";
echo 'Error getting object ' . $key . ' from bucket ' . $bucket . '. Make sure they exist and your bucket is in the same region as this function.' . "\n";
throw $e;
}
}
}
}
$logger = new StderrLogger();
return new Handler($logger);
```
------
#### [ Python ]
**SDK para Python (Boto3).**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no repositório dos [Exemplos sem servidor](https://github.com/aws-samples/serverless-snippets/tree/main/integration-s3-to-lambda).
Consumir um evento do S3 com o Lambda usando Python.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
import json
import urllib.parse
import boto3
print('Loading function')
s3 = boto3.client('s3')
def lambda_handler(event, context):
#print("Received event: " + json.dumps(event, indent=2))
# Get the object from the event and show its content type
bucket = event['Records'][0]['s3']['bucket']['name']
key = urllib.parse.unquote_plus(event['Records'][0]['s3']['object']['key'], encoding='utf-8')
try:
response = s3.get_object(Bucket=bucket, Key=key)
print("CONTENT TYPE: " + response['ContentType'])
return response['ContentType']
except Exception as e:
print(e)
print('Error getting object {} from bucket {}. Make sure they exist and your bucket is in the same region as this function.'.format(key, bucket))
raise e
```
------
#### [ Ruby ]
**SDK para Ruby**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no repositório dos [Exemplos sem servidor](https://github.com/aws-samples/serverless-snippets/tree/main/integration-s3-to-lambda).
Como consumir um evento do S3 com o Lambda usando Ruby.
```
require 'json'
require 'uri'
require 'aws-sdk'
puts 'Loading function'
def lambda_handler(event:, context:)
s3 = Aws::S3::Client.new(region: 'region') # Your AWS region
# puts "Received event: #{JSON.dump(event)}"
# Get the object from the event and show its content type
bucket = event['Records'][0]['s3']['bucket']['name']
key = URI.decode_www_form_component(event['Records'][0]['s3']['object']['key'], Encoding::UTF_8)
begin
response = s3.get_object(bucket: bucket, key: key)
puts "CONTENT TYPE: #{response.content_type}"
return response.content_type
rescue StandardError => e
puts e.message
puts "Error getting object #{key} from bucket #{bucket}. Make sure they exist and your bucket is in the same region as this function."
raise e
end
end
```
------
#### [ Rust ]
**SDK para Rust**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no repositório dos [Exemplos sem servidor](https://github.com/aws-samples/serverless-snippets/tree/main/integration-s3-to-lambda).
Consumir um evento do S3 com o Lambda usando Rust.
```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
use aws_lambda_events::event::s3::S3Event;
use aws_sdk_s3::{Client};
use lambda_runtime::{run, service_fn, Error, LambdaEvent};
/// Main function
#[tokio::main]
async fn main() -> Result<(), Error> {
tracing_subscriber::fmt()
.with_max_level(tracing::Level::INFO)
.with_target(false)
.without_time()
.init();
// Initialize the AWS SDK for Rust
let config = aws_config::load_from_env().await;
let s3_client = Client::new(&config);
let res = run(service_fn(|request: LambdaEvent| {
function_handler(&s3_client, request)
})).await;
res
}
async fn function_handler(
s3_client: &Client,
evt: LambdaEvent
) -> Result<(), Error> {
tracing::info!(records = ?evt.payload.records.len(), "Received request from SQS");
if evt.payload.records.len() == 0 {
tracing::info!("Empty S3 event received");
}
let bucket = evt.payload.records[0].s3.bucket.name.as_ref().expect("Bucket name to exist");
let key = evt.payload.records[0].s3.object.key.as_ref().expect("Object key to exist");
tracing::info!("Request is for {} and object {}", bucket, key);
let s3_get_object_result = s3_client
.get_object()
.bucket(bucket)
.key(key)
.send()
.await;
match s3_get_object_result {
Ok(_) => tracing::info!("S3 Get Object success, the s3GetObjectResult contains a 'body' property of type ByteStream"),
Err(_) => tracing::info!("Failure with S3 Get Object request")
}
Ok(())
}
```
------
1. No painel de **Origem do código** no console do Lambda, cole o código no editor de código, substituindo o código criado pelo Lambda.
1. Na seção **DEPLOY**, escolha **Implantar** para atualizar o código da função:
![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png)
## Criar o acionador do Amazon S3
![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/services-s3-example/s3trigger_tut_steps7.png)
**Para criar o acionador do Amazon S3**
1. No painel **Visão geral da função**, escolha **Adicionar gatilho**.
![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/overview-trigger.png)
1. Selecione **S3**.
1. Em **Bucket**, selecione o bucket que você criou anteriormente no tutorial.
1. Em **Tipos de eventos**, garanta que a opção **Todos os eventos de criação de objetos** esteja selecionada.
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.
1. Escolha **Adicionar**.
**nota**
Quando você cria um acionador do Amazon S3 para uma função do Lambda usando o console do Lambda, o Amazon S3 configura uma [notificação de evento](https://docs.aws.amazon.com/AmazonS3/latest/userguide/EventNotifications.html) no bucket que você especificar. Antes de configurar essa notificação de evento, o Amazon S3 executa uma série de verificações para confirmar que o destino do evento existe e tem as políticas do IAM necessárias. O Amazon S3 também executa esses testes em qualquer outra notificação de evento configurada para esse bucket.
Por causa dessa verificação, se o bucket tiver destinos de eventos previamente configurados para recursos que não existem mais ou para recursos que não têm as políticas de permissões necessárias, o Amazon S3 não poderá criar a nova notificação de evento. Você verá a seguinte mensagem de erro indicando que não foi possível criar seu acionador:
```
An error occurred when creating the trigger: Unable to validate the following destination configurations.
```
Você poderá ver esse erro se tiver configurado anteriormente um acionador para outra função do Lambda usando o mesmo bucket e, desde então, tiver excluído a função ou modificado suas políticas de permissões.
## Testar sua função do Lambda com um evento fictício
![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/services-s3-example/s3trigger_tut_steps8.png)
**Para testar a função do Lambda com um evento fictício**
1. Na página de console do Lambda da sua função, escolha a guia **Testar**.
![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/test-tab.png)
1. Em **Nome do evento**, insira `MyTestEvent`.
1. Em **Evento JSON**, cole o seguinte evento de teste. Não se esqueça de substituir estes valores:
+ Substitua `us-east-1` pela região em que você criou o bucket do Amazon S3.
+ Substitua ambas as instâncias de `amzn-s3-demo-bucket` pelo nome do seu próprio bucket do Amazon S3.
+ Substitua `test%2FKey` pelo nome do objeto de teste que você carregou anteriormente para o bucket (por exemplo, `HappyFace.jpg`).
```
{
"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. Escolha **Test** (Testar).
1. Se a função for executada com êxito, você verá uma saída semelhante à seguinte na guia **Resultados da execução**.
```
Response
"image/jpeg"
Function Logs
START RequestId: 12b3cae7-5f4e-415e-93e6-416b8f8b66e6 Version: $LATEST
2021-02-18T21:40:59.280Z 12b3cae7-5f4e-415e-93e6-416b8f8b66e6 INFO INPUT BUCKET AND KEY: { Bucket: 'amzn-s3-demo-bucket', Key: 'HappyFace.jpg' }
2021-02-18T21:41:00.215Z 12b3cae7-5f4e-415e-93e6-416b8f8b66e6 INFO CONTENT TYPE: image/jpeg
END RequestId: 12b3cae7-5f4e-415e-93e6-416b8f8b66e6
REPORT RequestId: 12b3cae7-5f4e-415e-93e6-416b8f8b66e6 Duration: 976.25 ms Billed Duration: 977 ms Memory Size: 128 MB Max Memory Used: 90 MB Init Duration: 430.47 ms
Request ID
12b3cae7-5f4e-415e-93e6-416b8f8b66e6
```
### Testar a função do Lambda com o acionador do Amazon S3
![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/services-s3-example/s3trigger_tut_steps9.png)
Para testar a função com o gatilho configurado, carregue um objeto para o bucket do Amazon S3 usando o console. Para verificar se a função do Lambda foi executada conforme planejado, use o CloudWatch Logs para visualizar a saída da sua função.
**Para carregar um objeto para o bucket do Amazon S3**
1. Abra a página [Buckets](https://console.aws.amazon.com/s3/buckets) do console do Amazon S3 e escolha o bucket que você criou anteriormente.
1. Escolha **Carregar**.
1. Escolha **Adicionar arquivos** e use o seletor de arquivos para escolher um objeto que você deseje carregar. Esse objeto pode ser qualquer arquivo que você escolher.
1. Selecione **Abrir** e **Carregar**.
**Para verificar a invocação da função usando o CloudWatch Logs**
1. [Abra o console do CloudWatch](https://console.aws.amazon.com/cloudwatch/home).
1. Verifique se você está trabalhando na mesma Região da AWS em que criou a função do Lambda. Você pode alterar sua 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 **Logs** e depois escolha **Grupos de logs**.
1. Escolha o nome do grupo de logs para sua função (`/aws/lambda/s3-trigger-tutorial`).
1. Em **Fluxos de logs**, escolha o fluxo de logs mais recente.
1. Se sua função tiver sido invocada corretamente em resposta ao gatilho do Amazon S3, você verá uma saída semelhante à seguinte. O `CONTENT TYPE` que você vê depende do tipo de arquivo que você carregou no bucket.
```
2022-05-09T23:17:28.702Z 0cae7f5a-b0af-4c73-8563-a3430333cc10 INFO CONTENT TYPE: image/jpeg
```
## 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 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**.
## Próximas etapas
No [Tutorial: Usar um acionador do Amazon S3 para criar imagens em miniatura](with-s3-tutorial.md), o gatilho do Amazon S3 invoca uma função para criar uma imagem em miniatura para cada arquivo de imagem que é carregado para um bucket. Este tutorial requer um nível moderado de conhecimento de domínios da AWS e do Lambda. Ele demonstra como criar recursos usando a AWS Command Line Interface (AWS CLI) e como criar um arquivo .zip de pacote de implantação de arquivamento para a sua função e suas dependências.
# 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**.