Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Didacticiel : utilisation d’un déclencheur Amazon S3 pour invoquer une fonction Lambda
<a name="with-s3-example"></a>

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.

![\[\]](http://docs.aws.amazon.com/fr_fr/lambda/latest/dg/images/services-s3-example/s3_tut_config.png)


Ce tutoriel montre comment :

1. Créez un compartiment Amazon S3.

1. Créez une fonction Lambda qui renvoie le type d’objet des objets dans un compartiment Amazon S3.

1. Configurez un déclencheur Lambda qui invoque votre fonction lorsque des objets sont chargés dans votre compartiment.

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

## Créer un compartiment Amazon S3
<a name="with-s3-example-create-bucket"></a>

![\[\]](http://docs.aws.amazon.com/fr_fr/lambda/latest/dg/images/services-s3-example/s3trigger_tut_steps1.png)


**Pour créer un compartiment Amazon S3**

1. Ouvrez la [console Amazon S3](https://console.aws.amazon.com/s3) et sélectionnez la page **Compartiments à usage général**.

1. Sélectionnez le Région AWS plus proche de votre situation géographique. Vous pouvez modifier votre région à l’aide de la liste déroulante en haut de l’écran. Plus loin dans le didacticiel, vous devez créer votre fonction Lambda dans la même région.  
![\[\]](http://docs.aws.amazon.com/fr_fr/lambda/latest/dg/images/console_region_select.png)

1. Choisissez **Create bucket** (Créer un compartiment).

1. Sous **Configuration générale**, procédez comme suit :

   1. Pour le **type de compartiment**, veillez à sélectionner **Usage général**.

   1. Pour le **nom du compartiment**, saisissez un nom unique au monde qui respecte les [règles de dénomination du compartiment](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucketnamingrules.html) Amazon S3. Les noms de compartiment peuvent contenir uniquement des lettres minuscules, des chiffres, de points (.) et des traits d’union (-).

1. 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
<a name="with-s3-example-upload-test-object"></a>

![\[\]](http://docs.aws.amazon.com/fr_fr/lambda/latest/dg/images/services-s3-example/s3trigger_tut_steps2.png)


**Pour charger un objet de test**

1. Ouvrez la page [Compartiments](https://console.aws.amazon.com/s3/buckets) de la console Amazon S3 et choisissez le compartiment que vous avez créé à l’étape précédente.

1. Choisissez **Charger**.

1. Choisissez **Ajouter des fichiers** et sélectionnez l’objet que vous souhaitez charger. Vous pouvez sélectionner n’importe quel fichier (par exemple, `HappyFace.jpg`).

1. Choisissez **Ouvrir**, puis **Charger**.

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

## Création d’une stratégie d’autorisations
<a name="with-s3-example-create-policy"></a>

![\[\]](http://docs.aws.amazon.com/fr_fr/lambda/latest/dg/images/services-s3-example/s3trigger_tut_steps3.png)


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**

1. Ouvrez la [page stratégies](https://console.aws.amazon.com/iam/home#/policies) de la console IAM.

1. Choisissez **Créer une stratégie**.

1. Choisissez l’onglet **JSON**, puis collez la stratégie personnalisée suivante dans l’éditeur 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. Choisissez **Suivant : Balises**.

1. Choisissez **Suivant : Vérification**.

1. Sous **Examiner une stratégie**, pour le **Nom** de la stratégie, saisissez **s3-trigger-tutorial**.

1. Choisissez **Créer une stratégie**.

## Créer un rôle d’exécution
<a name="with-s3-example-create-role"></a>

![\[\]](http://docs.aws.amazon.com/fr_fr/lambda/latest/dg/images/services-s3-example/s3trigger_tut_steps4.png)


Un [rôle d'exécution](lambda-intro-execution-role.md) est un rôle Gestion des identités et des accès AWS (IAM) qui accorde à une fonction Lambda l'autorisation d' Services AWS accès et de ressources. Dans cette étape, vous créez un rôle d’exécution à l’aide de la politique d’autorisations 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**

1. Ouvrez la [page Rôles](https://console.aws.amazon.com/iam/home#/roles) de la console IAM.

1. Sélectionnez **Créer un rôle**.

1. Pour le type d’entité de confiance, choisissez **Service AWS **, puis pour le cas d’utilisation, choisissez **Lambda**.

1. Choisissez **Suivant**.

1. Dans la zone de recherche de stratégie, entrez **s3-trigger-tutorial**.

1. Dans les résultats de la recherche, sélectionnez la stratégie que vous avez créée (`s3-trigger-tutorial`), puis choisissez **Suivant**.

1. 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
<a name="with-s3-example-create-function"></a>

![\[\]](http://docs.aws.amazon.com/fr_fr/lambda/latest/dg/images/services-s3-example/s3trigger_tut_steps5.png)


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

**Pour créer la fonction Lambda**

1. Ouvrez la [page Functions](https://console.aws.amazon.com/lambda/home#/functions) (Fonctions) de la console Lambda.

1. 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.  
![\[\]](http://docs.aws.amazon.com/fr_fr/lambda/latest/dg/images/console_region_select.png)

1. Choisissez **Créer une fonction**.

1. Choisissez **Créer à partir de zéro**.

1. Sous **Basic information** (Informations de base), procédez comme suit :

   1. Sous **Nom de la fonction**, saisissez `s3-trigger-tutorial`.

   1. Pour **Runtime**, choisissez **Python 3.14**.

   1. Pour **Architecture**, choisissez **x86\$164**.

1. 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**.

   1. Sélectionnez le `lambda-s3-trigger-role` que vous avez créé précédemment.

1. Choisissez **Créer une fonction**.

## Déployer le code de la fonction
<a name="with-s3-example-deploy-code"></a>

![\[\]](http://docs.aws.amazon.com/fr_fr/lambda/latest/dg/images/services-s3-example/s3trigger_tut_steps6.png)


Ce didacticiel utilise le moteur d'exécution Python 3.14, 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 de la clé de l’objet chargé et le nom du compartiment à partir du paramètre `event` qu’elle reçoit d’Amazon S3. La fonction utilise ensuite la méthode [get\$1object](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/s3/client/get_object.html) du AWS SDK pour 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**

1. Choisissez l’onglet **Python** dans la zone suivante et copiez le code.

------
#### [ .NET ]

**SDK pour .NET**  
 Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’[exemples sans serveur](https://github.com/aws-samples/serverless-snippets/tree/main/integration-s3-to-lambda). 
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 pour Go V2**  
 Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’[exemples sans serveur](https://github.com/aws-samples/serverless-snippets/tree/main/integration-s3-to-lambda). 
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**  
 Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’[exemples sans serveur](https://github.com/aws-samples/serverless-snippets/tree/main/integration-s3-to-lambda). 
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)**  
 Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’[exemples sans serveur](https://github.com/aws-samples/serverless-snippets/tree/main/integration-s3-to-lambda). 
Consommation d'un événement S3 avec Lambda en utilisant. 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);
       }
   };
   ```
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**  
 Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’[exemples sans serveur](https://github.com/aws-samples/serverless-snippets/tree/main/integration-s3-to-lambda). 
Consommation d’un événement S3 avec Lambda à l’aide de PHP.  

   ```
   <?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 ]

**Kit SDK for Python (Boto3)**  
 Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’[exemples sans serveur](https://github.com/aws-samples/serverless-snippets/tree/main/integration-s3-to-lambda). 
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**  
 Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’[exemples sans serveur](https://github.com/aws-samples/serverless-snippets/tree/main/integration-s3-to-lambda). 
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**  
 Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’[exemples sans serveur](https://github.com/aws-samples/serverless-snippets/tree/main/integration-s3-to-lambda). 
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(())
   }
   ```

------

1. Dans le volet **Code source** de la console Lambda, collez le code dans l’éditeur de code, en remplaçant le code créé par Lambda.

1. Dans la section **DÉPLOYER**, choisissez **Déployer** pour mettre à jour le code de votre fonction :  
![\[\]](http://docs.aws.amazon.com/fr_fr/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png)

## Création d’un déclencheur Amazon S3
<a name="with-s3-example-create-trigger"></a>

![\[\]](http://docs.aws.amazon.com/fr_fr/lambda/latest/dg/images/services-s3-example/s3trigger_tut_steps7.png)


**Pour créer le déclencheur Amazon S3**

1. Dans le volet de **Présentation de la fonction**, choisissez **Ajouter un déclencheur**.  
![\[\]](http://docs.aws.amazon.com/fr_fr/lambda/latest/dg/images/overview-trigger.png)

1. Sélectionnez **S3**.

1. Sous **Compartiment**, sélectionnez le compartiment que vous avez créé précédemment dans le didacticiel.

1. Sous **Types d’événements**, assurez-vous que **Tous les événements de création d’objet** est sélectionné.

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

1. Choisissez **Ajouter**.

**Note**  
Lorsque vous créez un déclencheur Amazon S3 pour une fonction Lambda à l’aide de la console Lambda, Amazon S3 configure une [notification d’événement](https://docs.aws.amazon.com/AmazonS3/latest/userguide/EventNotifications.html) sur le compartiment que vous spécifiez. Avant de configurer cette notification d’événement, Amazon S3 effectue une série de vérifications pour confirmer que la destination de l’événement existe et dispose des politiques IAM requises. Amazon S3 effectue également ces tests sur toutes les autres notifications d’événements configurées pour ce compartiment.  
En raison de cette vérification, si le compartiment a déjà configuré des destinations d’événements pour des ressources qui n’existent plus ou pour des ressources qui ne disposent pas des politiques d’autorisations requises, Amazon S3 ne sera pas en mesure de créer la nouvelle notification d’événement. Vous verrez le message d’erreur suivant indiquant que votre déclencheur n’a pas pu être créé :  

```
An error occurred when creating the trigger: Unable to validate the following destination configurations.
```
Vous pouvez voir cette erreur si vous avez précédemment configuré un déclencheur pour une autre fonction Lambda utilisant le même compartiment, et si vous avez depuis supprimé la fonction ou modifié ses politiques d’autorisations.

## Test de votre fonction Lambda à l’aide d’un événement fictif
<a name="with-s3-example-test-dummy-event"></a>

![\[\]](http://docs.aws.amazon.com/fr_fr/lambda/latest/dg/images/services-s3-example/s3trigger_tut_steps8.png)


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

1. Dans la page de votre fonction de la console Lambda, choisissez l’onglet **Tester**.  
![\[\]](http://docs.aws.amazon.com/fr_fr/lambda/latest/dg/images/test-tab.png)

1. Dans **Event name** (Nom de l’événement), saisissez `MyTestEvent`.

1. Dans le **JSON d’événement**, collez l’événement de test suivant. Veillez à 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 `amzn-s3-demo-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": "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. Choisissez **Enregistrer**.

1. Sélectionnez **Tester)**.

1. 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: '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
   ```

### Test de la fonction Lambda avec le déclencheur Amazon S3
<a name="with-s3-example-test-s3-trigger"></a>

![\[\]](http://docs.aws.amazon.com/fr_fr/lambda/latest/dg/images/services-s3-example/s3trigger_tut_steps9.png)


Pour tester votre fonction avec le déclencheur configuré, 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**

1. Ouvrez la page [Compartiments](https://console.aws.amazon.com/s3/buckets) de la console Amazon S3 et choisissez le compartiment que vous avez créé précédemment.

1. Choisissez **Charger**.

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

1. Choisissez **Ouvrir**, puis **Charger**.

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

1. Ouvrez la console [CloudWatch](https://console.aws.amazon.com/cloudwatch/home).

1. 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.  
![\[\]](http://docs.aws.amazon.com/fr_fr/lambda/latest/dg/images/console_region_select.png)

1. Choisissez **Journaux**, puis **Groupes de journaux**.

1. Choisissez le groupe de journaux de votre fonction (`/aws/lambda/s3-trigger-tutorial`).

1. Sous **Flux de journaux**, sélectionnez le flux de journaux le plus récent.

1. Si votre fonction a été invoquée correctement en réponse à votre déclencheur Amazon S3, vous obtiendrez une sortie similaire à celle 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
<a name="cleanup"></a>

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**

1. Ouvrez la [page Functions (Fonctions)](https://console.aws.amazon.com/lambda/home#/functions) de la console Lambda.

1. Sélectionnez la fonction que vous avez créée.

1. Sélectionnez **Actions**, **Supprimer**.

1. Saisissez **confirm** dans la zone de saisie de texte et choisissez **Delete** (Supprimer).

**Pour supprimer le rôle d’exécution**

1. Ouvrez la [page Roles (Rôles)](https://console.aws.amazon.com/iam/home#/roles) de la console IAM.

1. Sélectionnez le rôle d’exécution que vous avez créé.

1. Sélectionnez **Delete (Supprimer)**.

1. Saisissez le nom du rôle dans le champ de saisie de texte et choisissez **Delete** (Supprimer).

**Pour supprimer le compartiment S3**

1. Ouvrez la [console Amazon S3](https://console.aws.amazon.com//s3/home#).

1. Sélectionnez le compartiment que vous avez créé.

1. Sélectionnez **Delete (Supprimer)**.

1. Saisissez le nom du compartiment dans le champ de saisie de texte.

1. Choisissez **Supprimer le compartiment**.

## Étapes suivantes
<a name="next-steps"></a>

Dans [Didacticiel : Utilisation d’un déclencheur Amazon S3 pour créer des images miniatures](with-s3-tutorial.md), le déclencheur Amazon S3 invoque une fonction qui crée une image de miniature pour chaque fichier image qui est chargé dans votre 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.