Prérequis Créer un compartiment Amazon S3 Charger un objet de test dans votre compartiment Créer une stratégie d’autorisations Créer un rôle d’exécution Créer la fonction Lambda Déployer le code de la fonction Création d’un déclencheur Amazon S3 Test de la fonction Lambda Nettoyage de vos ressources Étapes suivantes

Didacticiel : utilisation d’un déclencheur Amazon S3 pour invoquer une fonction Lambda

Dans ce didacticiel, vous allez utiliser la console pour créer une fonction Lambda et configurer un déclencheur pour un compartiment Amazon Simple Storage Service (Amazon S3). Chaque fois que vous ajoutez un objet à votre compartiment Amazon S3, votre fonction s'exécute et affiche le type d'objet dans Amazon CloudWatch Logs.

Schéma illustrant le flux de données entre un compartiment Amazon S3, une fonction Lambda et Amazon Logs CloudWatch

Ce didacticiel explique comment :

Créez un compartiment Amazon S3.
Créez une fonction Lambda qui renvoie le type d’objet des objets dans un compartiment Amazon S3.
Configurez un déclencheur Lambda qui invoque votre fonction lorsque des objets sont chargés dans votre compartiment.
Testez votre fonction, d’abord avec un événement fictif, puis en utilisant le déclencheur.

En suivant ces étapes, vous apprendrez à configurer une fonction Lambda pour qu’elle s’exécute chaque fois que des objets sont ajoutés ou supprimés d’un compartiment Amazon S3. Vous pouvez compléter ce didacticiel en n’utilisant que la AWS Management Console.

Prérequis

Si vous n'en avez pas Compte AWS, procédez comme suit pour en créer un.

Pour vous inscrire à un Compte AWS

Ouvrez https://portal.aws.amazon.com/billing/signup.
Suivez les instructions en ligne.

Dans le cadre de la procédure d’inscription, vous recevrez un appel téléphonique et vous saisirez un code de vérification en utilisant le clavier numérique du téléphone.

Lorsque vous vous inscrivez à un Compte AWS, un Utilisateur racine d'un compte AWSest créé. Par défaut, seul l’utilisateur root a accès à l’ensemble des Services AWS et des ressources de ce compte. La meilleure pratique de sécurité consiste à attribuer un accès administratif à un utilisateur administratif, et à uniquement utiliser l’utilisateur root pour effectuer tâches nécessitant un accès utilisateur root.

AWS vous envoie un e-mail de confirmation une fois le processus d'inscription terminé. Vous pouvez afficher l’activité en cours de votre compte et gérer votre compte à tout moment en accédant à https://aws.amazon.com/ et en cliquant sur Mon compte.

Une fois que vous vous êtes inscrit à un utilisateur administratif Compte AWS, que vous Utilisateur racine d'un compte AWS l'avez sécurisé AWS IAM Identity Center, que vous l'avez activé et que vous en avez créé un, afin de ne pas utiliser l'utilisateur root pour les tâches quotidiennes.

Sécurisez votre Utilisateur racine d'un compte AWS

Connectez-vous en AWS Management Consoletant que propriétaire du compte en choisissant Utilisateur root et en saisissant votre adresse Compte AWS e-mail. Sur la page suivante, saisissez votre mot de passe.

Pour obtenir de l’aide pour vous connecter en utilisant l’utilisateur root, consultez Connexion en tant qu’utilisateur root dans le Guide de l’utilisateur Connexion à AWS .
Activez l’authentification multifactorielle (MFA) pour votre utilisateur root.

Pour obtenir des instructions, voir Activer un périphérique MFA virtuel pour votre utilisateur Compte AWS root (console) dans le guide de l'utilisateur IAM.

Création d’un utilisateur administratif

Activez IAM Identity Center.

Pour obtenir des instructions, consultez Activation d’ AWS IAM Identity Center dans le Guide de l’utilisateur AWS IAM Identity Center .
Dans IAM Identity Center, octroyez un accès administratif à un utilisateur administratif.

Pour un didacticiel sur l'utilisation du Répertoire IAM Identity Center comme source d'identité, voir Configurer l'accès utilisateur par défaut Répertoire IAM Identity Center dans le Guide de AWS IAM Identity Center l'utilisateur.

Connexion en tant qu’utilisateur administratif

Pour vous connecter avec votre utilisateur IAM Identity Center, utilisez l’URL de connexion qui a été envoyée à votre adresse e-mail lorsque vous avez créé l’utilisateur IAM Identity Center.

Pour obtenir de l'aide pour vous connecter en utilisant un utilisateur d'IAM Identity Center, consultez la section Connexion au portail AWS d'accès dans le guide de l'Connexion à AWS utilisateur.

Créer un compartiment Amazon S3

Diagramme de flux de travail du didacticiel montrant que vous êtes à l’étape de création d’un compartiment Amazon S3

Pour créer un compartiment Amazon S3

Ouvrez la console Amazon S3 et sélectionnez la page Compartiments.
Choisissez Create bucket (Créer un compartiment).
Sous Configuration générale, procédez comme suit :
1. Pour le nom du compartiment, saisissez un nom unique au monde qui respecte les règles de dénomination du compartiment Amazon S3. Les noms de compartiment peuvent contenir uniquement des lettres minuscules, des chiffres, de points (.) et des traits d’union (-).
2. Choisissez une région dans Région AWS . Plus loin dans le didacticiel, vous devez créer votre fonction Lambda dans la même région.
Conservez les valeurs par défaut de toutes les autres options et choisissez Créer un compartiment.

Charger un objet de test dans votre compartiment

Diagramme de flux de travail du didacticiel montrant que vous êtes à l’étape de chargement d’un objet de test dans le compartiment Amazon S3

Pour charger un objet de test

Ouvrez la page Compartiments de la console Amazon S3 et choisissez le compartiment que vous avez créé à l’étape précédente.
Sélectionnez Charger.
Choisissez Ajouter des fichiers et sélectionnez l'objet que vous souhaitez télécharger. Vous pouvez sélectionner n'importe quel fichier (par exemple,HappyFace.jpg).
Choisissez Ouvrir, puis Charger.

Plus loin dans le didacticiel, vous testerez votre fonction Lambda à l'aide de cet objet.

Créer une stratégie d’autorisations

Schéma de flux de travail du didacticiel montrant que vous êtes à l’étape de la fonction Lambda créant la stratégie d’autorisations

Créez une politique d'autorisation qui permet à Lambda d'obtenir des objets depuis un compartiment Amazon S3 et d'écrire dans Amazon CloudWatch Logs.

Pour créer la politique

Ouvrez la page stratégies de la console IAM.
Choisissez Créer une stratégie.

Choisissez l’onglet JSON, puis collez la stratégie personnalisée suivante dans l’éditeur 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:::*/*"
        }
    ]
}

Choisissez Suivant : Balises.
Choisissez Suivant : Vérification.
Sous Examiner une stratégie, pour le Nom de la stratégie, saisissez s3-trigger-tutorial.
Choisissez Créer une stratégie.

Créer un rôle d’exécution

Schéma de flux de travail du didacticiel vous montrant que vous êtes à l’étape de création d’un rôle d’exécution de la fonction Lambda

Un rôle d'exécution est un rôle AWS Identity and Access Management (IAM) qui accorde à une fonction Lambda l'autorisation d' AWS accéder aux services et aux ressources. Au cours de cette étape, créez un rôle d'exécution à l'aide de la politique d'autorisation que vous avez créée à l'étape précédente.

Pour créer un rôle d’exécution et attacher votre politique d’autorisations personnalisée

Ouvrez la page Rôles de la console IAM.
Sélectionnez Créer un rôle.
Pour le type d’entité de confiance, choisissez Service AWS , puis pour le cas d’utilisation, choisissez Lambda.
Choisissez Suivant.
Dans la zone de recherche de stratégie, entrez s3-trigger-tutorial.
Dans les résultats de la recherche, sélectionnez la stratégie que vous avez créée (s3-trigger-tutorial), puis choisissez Suivant.
Sous Role details (Détails du rôle), pour Role name (Nom du rôle), saisissez lambda-s3-trigger-role, puis sélectionnez Create role (Créer un rôle).

Créer la fonction Lambda

Diagramme de flux de travail du tutoriel vous montrant que vous êtes à l’étape de création de la fonction Lambda

Créez une fonction Lambda dans la console à l'aide de l'environnement d'exécution Python 3.12.

Pour créer la fonction Lambda

Ouvrez la page Functions (Fonctions) de la console Lambda.
Assurez-vous de travailler dans le même environnement que celui dans Région AWS lequel vous avez créé votre compartiment Amazon S3. Vous pouvez modifier votre région à l’aide de la liste déroulante en haut de l’écran.
Choisissez Créer une fonction.
Choisissez Créer à partir de zéro.
Sous Basic information (Informations de base), procédez comme suit :
1. Sous Nom de la fonction, saisissez s3-trigger-tutorial.
2. Pour Runtime, choisissez Python 3.12.
3. Pour Architecture, choisissez x86_64.
Dans l’onglet Modifier le rôle d’exécution par défaut, procédez comme suit :
1. Ouvrez l’onglet, puis choisissez Utiliser un rôle existant.
2. Sélectionnez le lambda-s3-trigger-role que vous avez créé précédemment.
Choisissez Créer une fonction.

Déployer le code de la fonction

Schéma de flux de travail du didacticiel vous montrant que vous êtes à l’étape de déploiement du code de la fonction Lambda

Ce didacticiel utilise le moteur d'exécution Python 3.12, mais nous avons également fourni des exemples de fichiers de code pour d'autres environnements d'exécution. Vous pouvez sélectionner l’onglet dans la zone suivante pour voir le code d’exécution qui vous intéresse.

La fonction Lambda récupère le nom clé de l'objet chargé et le nom du compartiment à partir du event paramètre qu'il reçoit d'Amazon S3. La fonction utilise ensuite la méthode get_object du AWS SDK for Python (Boto3) pour récupérer les métadonnées de l'objet, y compris le type de contenu (type MIME) de l'objet chargé.

Pour déployer le code de la fonction

Choisissez l'onglet Python dans la zone suivante et copiez le code.

.NET

AWS SDK for .NET

Note

Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’exemples sans serveur.

Utilisation d’un événement S3 avec Lambda en utilisant .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<string> 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

Kit SDK for Go V2

Note

Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’exemples sans serveur.

Utilisation d’un événement S3 avec Lambda en utilisant 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 pour Java 2.x

Note

Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’exemples sans serveur.

Utilisation d’un événement S3 avec Lambda en utilisant Go.


// 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<S3Event, String> {
    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 pour JavaScript (v3)

Note

Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’exemples sans serveur.

Consommation d'un événement S3 avec Lambda en utilisant. JavaScript


// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
import { S3Client, HeadObjectCommand } from "@aws-sdk/client-s3";

const client = new S3Client();

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

Consommation d'un événement S3 avec Lambda en utilisant. 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<string | undefined> => {
  // 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

Kit SDK pour PHP

Note

Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’exemples sans serveur.

Consommation d'un événement S3 avec Lambda à l'aide de PHP.


// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
<?php

use Bref\Context\Context;
use Bref\Event\S3\S3Event;
use Bref\Event\S3\S3Handler;
use Bref\Logger\StderrLogger;

require __DIR__ . '/vendor/autoload.php';


class Handler extends S3Handler 
{
    private StderrLogger $logger;
    public function __construct(StderrLogger $logger)
    {
        $this->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 pour Python (Boto3)

Note

Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’exemples sans serveur.

Utilisation d’un événement S3 avec Lambda en utilisant 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

Kit SDK pour Ruby

Note

Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’exemples sans serveur.

Consommation d'un événement S3 avec Lambda à l'aide de 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 pour Rust

Note

Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’exemples sans serveur.

Utilisation d’un événement S3 avec Lambda en utilisant 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<S3Event>| {
        function_handler(&s3_client, request)
    })).await;

    res
}

async fn function_handler(
    s3_client: &Client,
    evt: LambdaEvent<S3Event>
) -> 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(())
}

Dans le volet Source du code de la console Lambda, collez le code dans le fichier lambda_function.py.
Choisissez Deploy (Déployer).

Création d’un déclencheur Amazon S3

Schéma de flux de travail du didacticiel montrant que vous êtes à l’étape de création du déclencheur S3

Pour créer le déclencheur Amazon S3

Dans le volet de Présentation de la fonction, choisissez Ajouter un déclencheur.
Sélectionnez S3.
Sous Compartiment, sélectionnez le compartiment que vous avez créé précédemment dans le didacticiel.
Sous Types d'événements, assurez-vous que l'option Tous les événements de création d'objets est sélectionnée.
Sous Invocation récursive, cochez la case pour confirmer qu’il n’est pas recommandé d’utiliser le même compartiment Amazon S3 pour les entrées et les sorties.
Choisissez Ajouter.

Test de votre fonction Lambda à l’aide d’un événement fictif

Schéma de flux de travail du didacticiel vous montrant que vous êtes à l’étape du test avec un événement fictif

Pour tester la fonction Lambda à l’aide d’un événement fictif

Sur la page de console Lambda de votre fonction, choisissez l'onglet Test.
Dans Event name (Nom de l’événement), saisissez MyTestEvent.

Dans le fichier Event JSON, collez l'événement de test suivant. Assurez-vous de remplacer les valeurs suivantes :

Remplacez us-east-1 par la région dans laquelle vous avez créé votre compartiment Amazon S3.
Remplacez les deux instances de my-bucket par le nom de votre propre compartiment Amazon S3.
Remplacez test%2FKey par le nom de l’objet de test que vous avez chargé précédemment dans votre compartiment (par exemple, 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": "my-bucket",
          "ownerIdentity": {
            "principalId": "EXAMPLE"
          },
          "arn": "arn:aws:s3:::my-bucket"
        },
        "object": {
          "key": "test%2Fkey",
          "size": 1024,
          "eTag": "0123456789abcdef0123456789abcdef",
          "sequencer": "0A1B2C3D4E5F678901"
        }
      }
    }
  ]
}

Choisissez Save (Enregistrer).
Sélectionnez Tester).

Si votre fonction s’exécute correctement, vous obtiendrez un résultat similaire à celui qui suit dans l’onglet Résultats de l’exécution.


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: 'my-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

Test de la fonction Lambda avec le déclencheur Amazon S3

Schéma de flux de travail du didacticiel vous montrant que vous êtes à l’étape du test en utilisant le déclencheur S3

Pour tester votre fonction avec le déclencheur configuré, téléchargez un objet dans votre compartiment Amazon S3 à l'aide de la console. Pour vérifier que votre fonction Lambda s'est exécutée comme prévu, utilisez CloudWatch Logs pour afficher le résultat de votre fonction.

Pour charger un objet dans votre compartiment Amazon S3

Ouvrez la page Buckets de la console Amazon S3 et choisissez le bucket que vous avez créé précédemment.
Sélectionnez Charger.
Choisissez Ajouter des fichiers et utilisez le sélecteur de fichiers pour choisir l’objet que vous souhaitez charger. Cet objet peut être n’importe quel fichier que vous choisissez.
Choisissez Ouvrir, puis Charger.

Pour vérifier l'invocation de la fonction à l'aide CloudWatch de Logs

Ouvrez la console CloudWatch.
Assurez-vous de travailler de la même manière que celle dans laquelle Région AWS vous avez créé votre fonction Lambda. Vous pouvez modifier votre région à l’aide de la liste déroulante en haut de l’écran.
Choisissez Journaux, puis Groupes de journaux.
Choisissez le groupe de journaux de votre fonction (/aws/lambda/s3-trigger-tutorial).
Sous Flux de journaux, sélectionnez le flux de journaux le plus récent.
Si votre fonction a été invoquée correctement en réponse à votre déclencheur Amazon S3, vous verrez un résultat similaire à ce qui suit. Le CONTENT TYPE que vous voyez dépend du type de fichier que vous avez chargé dans votre compartiment.
```
2022-05-09T23:17:28.702Z	0cae7f5a-b0af-4c73-8563-a3430333cc10	INFO	CONTENT TYPE: image/jpeg
```

Nettoyage de vos ressources

Vous pouvez maintenant supprimer les ressources que vous avez créées pour ce didacticiel, sauf si vous souhaitez les conserver. En supprimant AWS les ressources que vous n'utilisez plus, vous évitez des frais inutiles pour votre Compte AWS.

Pour supprimer la fonction Lambda

Ouvrez la page Functions (Fonctions) de la console Lambda.
Sélectionnez la fonction que vous avez créée.
Sélectionnez Actions, Supprimer.
Saisissez delete dans la zone de saisie de texte et choisissez Delete (Supprimer).

Pour supprimer le rôle d’exécution

Ouvrez la page Roles (Rôles) de la console IAM.
Sélectionnez le rôle d’exécution que vous avez créé.
Sélectionnez Delete (Supprimer).
Saisissez le nom du rôle dans le champ de saisie de texte et choisissez Delete (Supprimer).

Pour supprimer le compartiment S3

Ouvrez la console Amazon S3.
Sélectionnez le compartiment que vous avez créé.
Sélectionnez Delete (Supprimer).
Saisissez le nom du compartiment dans le champ de saisie de texte.
Choisissez Supprimer le compartiment.

Étapes suivantes

DansDidacticiel : Utilisation d'un déclencheur Amazon S3 pour créer des images miniatures, le déclencheur Amazon S3 invoque une fonction qui crée une image miniature pour chaque fichier image chargé dans un compartiment. Ce didacticiel nécessite un niveau modéré de connaissance du AWS domaine Lambda. Il montre comment créer des ressources à l'aide de AWS Command Line Interface (AWS CLI) et comment créer un package de déploiement d'archives de fichiers .zip pour la fonction et ses dépendances.

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Didacticiel : Utilisation d'un déclencheur Amazon S3 pour créer des images miniatures