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.

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.

2. Crie uma função do Lambda que redimensiona uma imagem e envia uma miniatura para um bucket do Amazon S3.

3. Configure um acionador do Lambda que invoca a função quando os objetos são carregados no bucket de origem.

4. 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 (AWS Management Console).

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.

Pré-requisitos

Cadastrar-se em uma Conta da AWS

Se você ainda não tem Conta da AWS, siga as etapas a seguir para criar um.

Para se cadastrar em uma Conta da AWS

1. Abra https://portal.aws.amazon.com/billing/signup.

2. Siga as instruções online.

   Parte do procedimento de inscrição envolve receber uma chamada telefônica e inserir um código de verificação no teclado do telefone.

   Quando você se cadastra em uma Conta da AWS, um Usuário raiz da conta da AWS é criado. O usuário raiz tem acesso a todos os Serviços da AWS e atributos na conta. Como prática recomendada de segurança, atribua o acesso administrativo a um usuário e use somente o usuário-raiz para executar tarefas que exigem acesso de usuário-raiz.

A AWS envia um e-mail de confirmação depois que o processo de cadastramento é concluído. A qualquer momento, é possível visualizar as atividades da conta atual e gerenciar sua conta acessando https://aws.amazon.com/ e selecionando Minha conta.

Criar um usuário com acesso administrativo

Depois de se cadastrar em uma Conta da AWS, proteja seu Usuário raiz da conta da AWS, habilite o AWS IAM Identity Center e crie um usuário administrativo para não usar o usuário raiz em tarefas cotidianas.

Proteger seu Usuário raiz da conta da AWS

1. Faça login no AWS Management Console como o proprietário da conta ao escolher a opção Usuário raiz e inserir o endereço de e-mail da Conta da AWS. Na próxima página, insira sua senha.

   Para obter ajuda ao fazer login usando o usuário raiz, consulte Fazer login como usuário raiz no Guia do usuário do Início de Sessão da AWS.

2. Habilite a autenticação multifator (MFA) para o usuário raiz.

   Para obter instruções, consulte Habilitar um dispositivo MFA virtual para o usuário raiz de sua conta da Conta da AWS (console) no Guia do usuário do IAM.

Criar um usuário com acesso administrativo

1. Habilitar o IAM Identity Center.

   Para obter instruções, consulte Habilitar AWS IAM Identity Center no Guia do usuário do AWS IAM Identity Center.

2. No Centro de Identidade do IAM, conceda o acesso administrativo para um usuário.

   Para obter um tutorial sobre como usar o Diretório do Centro de Identidade do IAM como fonte de identidade, consulte Configurar o acesso dos usuários com o Diretório do Centro de Identidade do IAM padrão no Guia do usuário do AWS IAM Identity Center.

Iniciar sessão como o usuário com acesso administrativo

• Para fazer login com seu usuário do Centro de Identidade do IAM, use o URL de login que foi enviado ao seu endereço de e-mail quando você criou o usuário do Centro do Usuário do IAM.

  Para obter ajuda com o login utilizando um usuário do Centro de Identidade do IAM, consulte Fazer login no portal de acesso da AWS, no Guia do usuário do Início de Sessão da AWS.

Atribuir acesso a usuários adicionais

1. No Centro de Identidade do IAM, crie um conjunto de permissões que siga as práticas recomendadas de aplicação de permissões com privilégio mínimo.

   Para obter instruções, consulte Create a permission set no Guia do usuário do AWS IAM Identity Center.

2. Atribua usuários a um grupo e, em seguida, atribua o acesso de autenticação única ao grupo.

   Para obter instruções, consulte Add groups no Guia do usuário do AWS IAM Identity Center.

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.

Crie dois buckets do Amazon S3

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.

AWS Management Console

Criar os buckets do Amazon S3 (console)

1. Abra a página Buckets do console do Amazon S3.

2. Selecione Criar bucket.

3. Em General configuration (Configuração geral), faça o seguinte:

   1. Em Nome do bucket, insira um nome global exclusivo que atenda às regras de nomenclatura de buckets do Amazon S3. Os nomes dos buckets podem conter apenas letras minúsculas, números, pontos (.) e hifens (-).

   2. Em Região da AWS, escolha a Região da AWS mais próxima de sua localização geográfica. Posteriormente no tutorial, você deverá criar a função do Lambda na mesma Região da AWS, portanto, anote a região escolhida.

4. Deixe todas as outras opções com seus valores padrão e escolha Criar bucket.

5. Repita as etapas 1 a 4 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 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 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.

2. 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

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.

AWS Management Console

Fazer upload de uma imagem de teste para o bucket de origem (console)

1. Abra a página Buckets do console do Amazon S3.

2. Selecione o bucket de origem criado na etapa anterior.

3. Escolha Carregar.

4. Escolha Adicionar arquivos e use o seletor de arquivos para escolher o objeto que você deseja carregar.

5. 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

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.

AWS Management Console

Criar a política (console)

1. Abra a página Policies (Políticas) do console do AWS Identity and Access Management (IAM).

2. Escolha Criar política.

3. 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:::*/*"
           }
       ]
   }

4. Escolha Próximo.

5. No campo Detalhes da política, em Nome da política, insira LambdaS3Policy.

6. 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:::*/*"
           }
       ]
   }

2. 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

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.

AWS Management Console

Criar um perfil de execução e anexar a política de permissões (console)

1. Abra a página Perfis no console do IAM.

2. Selecione Criar função.

3. Em Tipo de entidade confiável, selecione Serviço da AWS, e em Caso de uso, selecione Lambda.

4. Escolha Próximo.

5. Adicione a política de permissões criada na etapa anterior fazendo o seguinte:

   1. Na caixa de pesquisa de política, insira LambdaS3Policy.

   2. Nos resultados da pesquisa, marque a caixa de seleção LambdaS3Policy.

   3. Escolha Próximo.

6. Em Detalhes do perfil, em Nome do perfil, insira LambdaS3Role.

7. Selecione Criar função.

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"
       }
     ]
   }

2. 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

3. 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

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

2. 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

3. 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);
     };

4. 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

5. 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))

2. 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) e o AWS SDK for 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.

   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++. 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.

3. 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.

Você também pode criar seu pacote de implantação usando um ambiente virtual Python. Consulte Trabalhar com arquivos .zip para funções do Lambda em Python

Criar a função do Lambda

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.

AWS Management Console

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 do console do Lambda.

2. 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.

   

3. Escolha Create function (Criar função).

4. Escolha Author from scratch (Criar do zero).

5. Em Basic information (Informações básicas), faça o seguinte:

   1. Em Function name (Nome da função), insira CreateThumbnail.

   2. Em Runtime, escolha Node.js 20.x ou Python 3.12 de acordo com a linguagem que você escolheu para a função.

   3. Em Architecture (Arquitetura), escolha x86_64.

6. 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.

   2. Selecione a LambdaS3Role que você criou anteriormente.

7. Escolha Criar função.

Fazer upload do código da função (console)

1. No painel do Código-fonte, escolha Carregar de.

2. Escolha o arquivo .zip.

3. Escolha Carregar.

4. No seletor de arquivos, selecione o arquivo .zip e escolha Abrir.

5. 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 nodejs20.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.12 --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

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. Isso pode resultar em cobranças inesperadas para sua Conta da AWS.

AWS Management Console

Configurar o acionador do Amazon S3 (console)

1. Abra a página de Funções do console do Lambda e escolha sua função (CreateThumbnail).

2. Escolha Add trigger.

3. Selecione S3.

4. Em Bucket, selecione o bucket de origem.

5. Em Tipos de eventos, selecione Todos os eventos de criação de objetos.

6. 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 no Serverless Land.

7. Escolha Adicionar.

   Quando você cria um acionador usando o console do Lambda, o Lambda cria automaticamente uma política baseada em recursos 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. 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).

2. 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" ]
       }
     ]
   }

3. 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 na Referência de comandos da CLI da AWS.

Testar sua função do Lambda com um evento fictício

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.

AWS Management Console

Testar a função do Lambda com um evento fictício (console)

1. Abra a página de Funções do console do Lambda e escolha sua função (CreateThumbnail).

2. Selecione a guia Testar.

3. 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.

   2. Em Nome do evento, insira myTestEvent.

   3. Em Modelo, selecione S3 Put.

   4. 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.

      {
        "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"
              }
            }
          }
        ]
      }

   5. Escolha Salvar.

4. No painel Evento de teste, escolha Testar.

5. 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 do console do Amazon S3.

   2. 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.

   {
     "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"
           }
         }
       }
     ]
   }

2. 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.

   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.

3. 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

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.

AWS Management Console

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 do console do Amazon S3 e escolha o bucket de origem.

   2. Escolha Carregar.

   3. 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.

   4. Selecione Abrir e Carregar.

2. 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 do console do Amazon S3 e escolha o bucket de destino.

   2. 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

2. 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 (Funções) no console do Lambda.

2. Selecione a função que você criou.

3. Escolha Ações, Excluir.

4. Digite delete no campo de entrada de texto e escolha Delete (Excluir).

Para excluir a política que você criou

1. Abra a página Policies (Políticas) do console do IAM.

2. Selecione a política que você criou (AWSLambdaS3Policy).

3. Escolha Policy actions (Ações de política) e Delete (Excluir).

4. Escolha Excluir.

Para excluir a função de execução

1. Abra a página Roles (Funções) no console do IAM.

2. Selecione a função de execução que você criou.

3. Escolha Excluir.

4. 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.

2. Selecione o bucket que você criou.

3. Escolha Excluir.

4. Insira o nome do bucket no campo de entrada de texto.

5. Escolha Excluir bucket.