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.
# Traiter les notifications d’événements Amazon S3 avec Lambda
Vous pouvez utiliser Lambda pour traiter les [notifications d’événement](https://docs.aws.amazon.com/AmazonS3/latest/userguide/NotificationHowTo.html) d’Amazon Simple Storage Service. Amazon S3 peut envoyer un événement à une fonction Lambda lors de la création ou de la suppression d’un objet. Vous configurez des paramètres de notification sur un compartiment et accordez à Amazon S3 l’autorisation d’appeler une fonction sur la stratégie d’autorisations basée sur une ressource de la fonction.
**Avertissement**
Si votre fonction Lambda utilise le même compartiment que celui qui la déclenche, la fonction risque de s’exécuter en boucle. Par exemple, si le compartiment déclenche une fonction chaque fois qu’un objet est chargé et que la fonction charge un objet dans le compartiment, la fonction se déclenche elle-même indirectement. Afin d’éviter cela, utilisez deux compartiments ou configurez le déclencheur pour qu’il s’applique uniquement à un préfixe utilisé pour les objets entrants.
Amazon S3 appelle votre fonction [de manière asynchrone](invocation-async.md) avec un événement contenant des détails sur l’objet. L’exemple suivant montre un événement envoyé par Amazon S3 lors du chargement d’un package de déploiement vers Amazon S3.
**Example Evénement de notification Amazon S3**
```
{
"Records": [
{
"eventVersion": "2.1",
"eventSource": "aws:s3",
"awsRegion": "us-east-2",
"eventTime": "2019-09-03T19:37:27.192Z",
"eventName": "ObjectCreated:Put",
"userIdentity": {
"principalId": "AWS:AIDAINPONIXQXHT3IKHL2"
},
"requestParameters": {
"sourceIPAddress": "205.255.255.255"
},
"responseElements": {
"x-amz-request-id": "D82B88E5F771F645",
"x-amz-id-2": "vlR7PnpV2Ce81l0PRw6jlUpck7Jo5ZsQjryTjKlc5aLWGVHPZLj5NeC6qMa0emYBDXOo6QBU0Wo="
},
"s3": {
"s3SchemaVersion": "1.0",
"configurationId": "828aa6fc-f7b5-4305-8584-487c791949c1",
"bucket": {
"name": "amzn-s3-demo-bucket",
"ownerIdentity": {
"principalId": "A3I5XTEXAMAI3E"
},
"arn": "arn:aws:s3:::lambda-artifacts-deafc19498e3f2df"
},
"object": {
"key": "b21b84d653bb07b05b1e6b33684dc11b",
"size": 1305107,
"eTag": "b21b84d653bb07b05b1e6b33684dc11b",
"sequencer": "0C0F6F405D6ED209E1"
}
}
}
]
}
```
Pour appeler votre fonction, Amazon S3 a besoin d’une autorisation de la [stratégie basée sur une ressource](access-control-resource-based.md). Lorsque vous configurez un déclencheur Amazon S3 dans la console Lambda, cette dernière modifie la stratégie basée sur une ressource pour permettre à Amazon S3 d’appeler la fonction si le nom du compartiment et l’ID de compte correspondent. Si vous configurez la notification dans Amazon S3, vous utilisez l’API Lambda pour mettre à jour la stratégie. Vous pouvez également utiliser l’API Lambda pour accorder une autorisation à un autre compte ou limiter l’autorisation à un alias désigné.
Si votre fonction utilise le AWS SDK pour gérer les ressources Amazon S3, elle a également besoin des autorisations Amazon S3 dans son [rôle d'exécution](lambda-intro-execution-role.md).
**Topics**
+ [Didacticiel : utilisation d’un déclencheur Amazon S3 pour invoquer une fonction Lambda](with-s3-example.md)
+ [Didacticiel : Utilisation d’un déclencheur Amazon S3 pour créer des images miniatures](with-s3-tutorial.md)
# 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.
![\[\]](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
![\[\]](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
![\[\]](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
![\[\]](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
![\[\]](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
![\[\]](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
![\[\]](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 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 {
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 => {
// 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.
```
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| {
function_handler(&s3_client, request)
})).await;
res
}
async fn function_handler(
s3_client: &Client,
evt: LambdaEvent
) -> Result<(), Error> {
tracing::info!(records = ?evt.payload.records.len(), "Received request from SQS");
if evt.payload.records.len() == 0 {
tracing::info!("Empty S3 event received");
}
let bucket = evt.payload.records[0].s3.bucket.name.as_ref().expect("Bucket name to exist");
let key = evt.payload.records[0].s3.object.key.as_ref().expect("Object key to exist");
tracing::info!("Request is for {} and object {}", bucket, key);
let s3_get_object_result = s3_client
.get_object()
.bucket(bucket)
.key(key)
.send()
.await;
match s3_get_object_result {
Ok(_) => tracing::info!("S3 Get Object success, the s3GetObjectResult contains a 'body' property of type ByteStream"),
Err(_) => tracing::info!("Failure with S3 Get Object request")
}
Ok(())
}
```
------
1. 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
![\[\]](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
![\[\]](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
![\[\]](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
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
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.
# Didacticiel : Utilisation d’un déclencheur Amazon S3 pour créer des images miniatures
Dans ce tutoriel, vous allez créer et configurer une fonction Lambda qui redimensionne les images ajoutées à un compartiment Amazon Simple Storage Service (Amazon S3). Lorsque vous ajoutez un fichier image à votre compartiment, Amazon S3 invoque votre fonction Lambda. La fonction crée ensuite une version miniature de l’image et l’envoie vers un autre compartiment Amazon S3.
![\[\]](http://docs.aws.amazon.com/fr_fr/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_resources.png)
Pour compléter ce didacticiel, effectuez les tâches suivantes :
1. Créez des compartiments Amazon S3 source et de destination et chargez un exemple d’image.
1. Créez une fonction Lambda qui redimensionne une image et envoie une miniature vers un compartiment Amazon S3.
1. Configurez un déclencheur Lambda qui invoque votre fonction lorsque des objets sont chargés dans votre compartiment source.
1. Testez votre fonction, d’abord avec un événement fictif, puis en chargeant une image dans votre compartiment source.
En suivant ces étapes, vous apprendrez à utiliser Lambda pour effectuer une tâche de traitement de fichiers sur des objets ajoutés à un compartiment Amazon S3. Vous pouvez suivre ce didacticiel en utilisant le AWS Command Line Interface (AWS CLI) ou le AWS Management Console.
Si vous recherchez un exemple plus simple pour apprendre à configurer un déclencheur Amazon S3 pour Lambda, vous pouvez consulter le [Didacticiel : utilisation d’un déclencheur Amazon S3 pour invoquer une fonction Lambda](https://docs.aws.amazon.com/lambda/latest/dg/with-s3-example.html).
**Topics**
+ [Conditions préalables](#with-s3-example-prereqs)
+ [Création de deux compartiments Amazon S3](#with-s3-tutorial-prepare-create-buckets)
+ [Charger une image de test dans votre compartiment source](#with-s3-tutorial-test-image)
+ [Création d’une stratégie d’autorisations](#with-s3-tutorial-create-policy)
+ [Créer un rôle d’exécution](#with-s3-tutorial-create-execution-role)
+ [Créer le package de déploiement de la fonction](#with-s3-tutorial-create-function-package)
+ [Créer la fonction Lambda](#with-s3-tutorial-create-function-createfunction)
+ [Configurer Amazon S3 pour invoquer la fonction](#with-s3-tutorial-configure-s3-trigger)
+ [Test de votre fonction Lambda à l’aide d’un événement fictif](#with-s3-tutorial-dummy-test)
+ [Tester votre fonction à l’aide du déclencheur Amazon S3](#with-s3-tutorial-test-s3)
+ [Nettoyage de vos ressources](#s3-tutorial-cleanup)
## Conditions préalables
Si vous souhaitez utiliser le AWS CLI pour terminer le didacticiel, installez la [dernière version du AWS Command Line Interface]().
Pour le code de votre fonction Lambda, vous pouvez utiliser Python ou Node.js. Installez les outils de prise en charge linguistique et un gestionnaire de packages pour le langage que vous souhaitez utiliser.
### Installez le AWS Command Line Interface
Si vous ne l'avez pas encore installé AWS Command Line Interface, suivez les étapes décrites dans la [section Installation ou mise à jour de la dernière version du AWS CLI pour l'](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)installer.
Ce tutoriel nécessite un terminal de ligne de commande ou un shell pour exécuter les commandes. Sous Linux et macOS, utilisez votre gestionnaire de shell et de package préféré.
**Note**
Sous Windows, certaines commandes CLI Bash que vous utilisez couramment avec Lambda (par exemple `zip`) ne sont pas prises en charge par les terminaux intégrés du système d’exploitation. [Installez le sous-système Windows pour Linux](https://docs.microsoft.com/en-us/windows/wsl/install-win10) afin d’obtenir une version intégrée à Windows d’Ubuntu et Bash.
## Création de deux compartiments Amazon S3
![\[\]](http://docs.aws.amazon.com/fr_fr/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_steps1.png)
Créez d’abord deux compartiments Amazon S3. Le premier compartiment est le compartiment source dans lequel vous allez charger vos images. Le second compartiment est utilisé par Lambda pour enregistrer la miniature redimensionnée lorsque vous invoquez votre fonction.
------
#### [ AWS Management Console ]
**Pour créer les compartiments Amazon S3 (console)**
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**.
1. Répétez les étapes 1 à 5 pour créer votre compartiment de destination. Pour **Nom du compartiment**, saisissez `amzn-s3-demo-source-bucket-resized`, où `amzn-s3-demo-source-bucket` est le nom du compartiment source que vous venez de créer.
------
#### [ AWS CLI ]
**Pour créer les compartiments Amazon S3 (AWS CLI)**
1. Exécutez la commande CLI suivante pour créer votre compartiment source. Le nom que vous choisissez pour votre compartiment doit être unique au monde et respecter les [Règles de dénomination du compartiment](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucketnamingrules.html) Amazon S3. Les noms peuvent contenir uniquement des lettres minuscules, des chiffres, de points (.) et des traits d’union (-). Pour `region` et `LocationConstraint`, choisissez la [Région AWS](https://docs.aws.amazon.com/general/latest/gr/lambda-service.html) la plus proche de votre emplacement géographique.
```
aws s3api create-bucket --bucket amzn-s3-demo-source-bucket --region us-east-1 \
--create-bucket-configuration LocationConstraint=us-east-1
```
Plus loin dans le didacticiel, vous devez créer votre fonction Lambda dans le même Région AWS emplacement que votre compartiment source. Notez donc la région que vous avez choisie.
1. Exécutez la commande suivante pour créer votre compartiment de destination. Pour le nom du compartiment, vous devez utiliser `amzn-s3-demo-source-bucket-resized`, où `amzn-s3-demo-source-bucket` est le nom du compartiment source que vous avez créé à l’étape 1. Pour `region` et`LocationConstraint`, choisissez le même Région AWS que celui que vous avez utilisé pour créer votre bucket source.
```
aws s3api create-bucket --bucket amzn-s3-demo-source-bucket-resized --region us-east-1 \
--create-bucket-configuration LocationConstraint=us-east-1
```
------
## Charger une image de test dans votre compartiment source
![\[\]](http://docs.aws.amazon.com/fr_fr/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_steps2.png)
Plus loin dans le didacticiel, vous testerez votre fonction Lambda en l'invoquant à l'aide de la console Lambda ou de AWS CLI la console Lambda. Pour confirmer que votre fonction fonctionne correctement, votre compartiment source doit contenir une image de test. Cette image peut être n’importe quel fichier JPG ou PNG de votre choix.
------
#### [ AWS Management Console ]
**Pour charger une image de test dans votre compartiment source (console)**
1. Ouvrez la page [Compartiments](https://console.aws.amazon.com/s3/buckets) de la console Amazon S3.
1. Sélectionnez le compartiment source que vous avez créé à l’étape précédente.
1. Choisissez **Charger**.
1. Choisissez **Ajouter des fichiers** et utilisez le sélecteur de fichiers pour sélectionner l’objet que vous souhaitez charger.
1. Choisissez **Ouvrir**, puis **Charger**.
------
#### [ AWS CLI ]
**Pour charger une image de test dans votre compartiment source (AWS CLI)**
+ À partir du répertoire contenant l’image que vous souhaitez charger, exécutez la commande CLI suivante. Remplacez le paramètre `--bucket` par le nom de votre compartiment source. Pour les paramètres `--key` et `--body`, utilisez le nom de fichier de votre image de test.
```
aws s3api put-object --bucket amzn-s3-demo-source-bucket --key HappyFace.jpg --body ./HappyFace.jpg
```
------
## Création d’une stratégie d’autorisations
![\[\]](http://docs.aws.amazon.com/fr_fr/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_steps3.png)
La première étape de la création de votre fonction Lambda consiste à créer une politique d’autorisations. Cette politique donne à votre fonction les autorisations dont elle a besoin pour accéder à d'autres AWS ressources. Pour ce didacticiel, la politique donne à Lambda des autorisations de lecture et d'écriture pour les compartiments Amazon S3 et lui permet d'écrire dans Amazon Logs. CloudWatch
------
#### [ AWS Management Console ]
**Pour créer une politique (console)**
1. Ouvrez la page [Politiques](https://console.aws.amazon.com/iamv2/home#policies) de la console Gestion des identités et des accès AWS (IAM).
1. Choisissez **Create Policy** (Créer une politique).
1. 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:::*/*"
},
{
"Effect": "Allow",
"Action": [
"s3:PutObject"
],
"Resource": "arn:aws:s3:::*/*"
}
]
}
```
1. Choisissez **Suivant**.
1. Sous **Détails de la politique**, pour le **Nom** de la politique, saisissez `LambdaS3Policy`.
1. Choisissez **Create Policy** (Créer une politique).
------
#### [ AWS CLI ]
**Pour créer la politique (AWS CLI)**
1. Enregistrez le JSON suivant dans un fichier nommé `policy.json`.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"logs:PutLogEvents",
"logs:CreateLogGroup",
"logs:CreateLogStream"
],
"Resource": "arn:aws:logs:*:*:*"
},
{
"Effect": "Allow",
"Action": [
"s3:GetObject"
],
"Resource": "arn:aws:s3:::*/*"
},
{
"Effect": "Allow",
"Action": [
"s3:PutObject"
],
"Resource": "arn:aws:s3:::*/*"
}
]
}
```
1. À partir du répertoire dans lequel vous avez enregistré le document de politique JSON, exécutez la commande CLI suivante.
```
aws iam create-policy --policy-name LambdaS3Policy --policy-document file://policy.json
```
------
## Créer un rôle d’exécution
![\[\]](http://docs.aws.amazon.com/fr_fr/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_steps4.png)
Un rôle d'exécution est un rôle IAM qui accorde à une fonction Lambda l'autorisation d' Services AWS accès et de ressources. Pour donner à votre fonction un accès en lecture et en écriture à un compartiment Amazon S3, vous attachez la politique d’autorisation que vous avez créée à l’étape précédente.
------
#### [ AWS Management Console ]
**Pour créer un rôle d’exécution et attacher votre politique d’autorisations (console)**
1. Accédez à la Page [Rôles](https://console.aws.amazon.com/iamv2/home#roles) de la console (IAM).
1. Choisissez **Créer un rôle**.
1. Pour **Type d’entité fiable**, sélectionnez **Service AWS**, et pour **Cas d’utilisation**, sélectionnez **Lambda**.
1. Choisissez **Suivant**.
1. Ajoutez la politique d’autorisations que vous avez créée à l’étape précédente en procédant comme suit :
1. Dans la zone de recherche de stratégie, entrez `LambdaS3Policy`.
1. Dans les résultats de la recherche, cochez la case pour `LambdaS3Policy`.
1. Choisissez **Suivant**.
1. Sous **Détails du rôle**, pour le **Nom du rôle** entrez `LambdaS3Role`.
1. Choisissez **Créer un rôle**.
------
#### [ AWS CLI ]
**Pour créer un rôle d’exécution et attacher votre politique d’autorisations (AWS CLI)**
1. Enregistrez le JSON suivant dans un fichier nommé `trust-policy.json`. Cette politique de confiance permet à Lambda d'utiliser les autorisations du rôle en autorisant le principal `lambda.amazonaws.com` du service à appeler l'action AWS Security Token Service (AWS STS)`AssumeRole`.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
1. À partir du répertoire dans lequel vous avez enregistré le document de politique d’approbation JSON, exécutez la commande CLI suivante pour créer le rôle d’exécution.
```
aws iam create-role --role-name LambdaS3Role --assume-role-policy-document file://trust-policy.json
```
1. Pour attacher la politique d’autorisations que vous avez créée à l’étape précédente, exécutez la commande CLI suivante. Remplacez le Compte AWS numéro indiqué dans l'ARN de la politique par votre propre numéro de compte.
```
aws iam attach-role-policy --role-name LambdaS3Role --policy-arn arn:aws:iam::123456789012:policy/LambdaS3Policy
```
------
## Créer le package de déploiement de la fonction
![\[\]](http://docs.aws.amazon.com/fr_fr/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_steps5.png)
Pour créer votre fonction, vous créez un *package de déploiement* contenant le code de votre fonction et ses dépendances. Pour cette fonction `CreateThumbnail`, votre code de fonction utilise une bibliothèque distincte pour le redimensionnement de l’image. Suivez les instructions correspondant à la langue de votre choix pour créer un package de déploiement contenant la bibliothèque requise.
------
#### [ Node.js ]
**Pour créer le package de déploiement (Node.js)**
1. Créez un répertoire nommé `lambda-s3` pour votre code de fonction et vos dépendances et accédez-y.
```
mkdir lambda-s3
cd lambda-s3
```
1. Créez un nouveau projet Node.js avec `npm`. Appuyez sur `Enter` pour accepter les options par défaut fournies dans l’expérience interactive.
```
npm init
```
1. Enregistrez le code de fonction suivant dans un fichier nommé `index.mjs`. Assurez-vous de remplacer `us-east-1` par l’ Région AWS dans lequel vous avez créé vos propres compartiments source et de destination.
```
// dependencies
import { S3Client, GetObjectCommand, PutObjectCommand } from '@aws-sdk/client-s3';
import { Readable } from 'stream';
import sharp from 'sharp';
import util from 'util';
// create S3 client
const s3 = new S3Client({region: 'us-east-1'});
// define the handler function
export const handler = async (event, context) => {
// Read options from the event parameter and get the source bucket
console.log("Reading options from event:\n", util.inspect(event, {depth: 5}));
const srcBucket = event.Records[0].s3.bucket.name;
// Object key may have spaces or unicode non-ASCII characters
const srcKey = decodeURIComponent(event.Records[0].s3.object.key.replace(/\+/g, " "));
const dstBucket = srcBucket + "-resized";
const dstKey = "resized-" + srcKey;
// Infer the image type from the file suffix
const typeMatch = srcKey.match(/\.([^.]*)$/);
if (!typeMatch) {
console.log("Could not determine the image type.");
return;
}
// Check that the image type is supported
const imageType = typeMatch[1].toLowerCase();
if (imageType != "jpg" && imageType != "png") {
console.log(`Unsupported image type: ${imageType}`);
return;
}
// Get the image from the source bucket. GetObjectCommand returns a stream.
try {
const params = {
Bucket: srcBucket,
Key: srcKey
};
var response = await s3.send(new GetObjectCommand(params));
var stream = response.Body;
// Convert stream to buffer to pass to sharp resize function.
if (stream instanceof Readable) {
var content_buffer = Buffer.concat(await stream.toArray());
} else {
throw new Error('Unknown object stream type');
}
} catch (error) {
console.log(error);
return;
}
// set thumbnail width. Resize will set the height automatically to maintain aspect ratio.
const width = 200;
// Use the sharp module to resize the image and save in a buffer.
try {
var output_buffer = await sharp(content_buffer).resize(width).toBuffer();
} catch (error) {
console.log(error);
return;
}
// Upload the thumbnail image to the destination bucket
try {
const destparams = {
Bucket: dstBucket,
Key: dstKey,
Body: output_buffer,
ContentType: "image"
};
const putResult = await s3.send(new PutObjectCommand(destparams));
} catch (error) {
console.log(error);
return;
}
console.log('Successfully resized ' + srcBucket + '/' + srcKey +
' and uploaded to ' + dstBucket + '/' + dstKey);
};
```
1. Dans votre répertoire `lambda-s3`, installez la bibliothèque sharp en utilisant npm. Notez que la dernière version de sharp (0.33) n’est pas compatible avec Lambda. Installez la version 0.32.6 pour terminer ce didacticiel.
```
npm install sharp@0.32.6
```
La commande npm `install` crée un répertoire `node_modules` pour vos modules. Après cette étape, votre structure de répertoire doit se présenter comme suit.
```
lambda-s3
|- index.mjs
|- node_modules
| |- base64js
| |- bl
| |- buffer
...
|- package-lock.json
|- package.json
```
1. Créez un package de déploiement .zip contenant le code de votre fonction et ses dépendances. Sous macOS ou Linux, exécutez les commandes suivantes.
```
zip -r function.zip .
```
Sous Windows, utilisez l’utilitaire zip de votre choix pour créer un fichier .zip. Assurez-vous que vos fichiers `index.mjs`, `package.json`, et `package-lock.json` ainsi que votre répertoire `node_modules` se trouvent tous à la racine de votre fichier .zip.
------
#### [ Python ]
**Pour créer le package de déploiement (Python)**
1. Enregistrez l’exemple de code en tant que fichier nommé `lambda_function.py`.
```
import boto3
import os
import sys
import uuid
from urllib.parse import unquote_plus
from PIL import Image
import PIL.Image
s3_client = boto3.client('s3')
def resize_image(image_path, resized_path):
with Image.open(image_path) as image:
image.thumbnail(tuple(x / 2 for x in image.size))
image.save(resized_path)
def lambda_handler(event, context):
for record in event['Records']:
bucket = record['s3']['bucket']['name']
key = unquote_plus(record['s3']['object']['key'])
tmpkey = key.replace('/', '')
download_path = '/tmp/{}{}'.format(uuid.uuid4(), tmpkey)
upload_path = '/tmp/resized-{}'.format(tmpkey)
s3_client.download_file(bucket, key, download_path)
resize_image(download_path, upload_path)
s3_client.upload_file(upload_path, '{}-resized'.format(bucket), 'resized-{}'.format(key))
```
1. Dans le même répertoire que celui dans lequel vous avez créé votre fichier `lambda_function.py`, créez un nouveau répertoire nommé `package` et installez la bibliothèque [Pillow (PIL)](https://pypi.org/project/Pillow/) et AWS SDK pour Python (Boto3). Bien que l’exécution Lambda Python inclut une version du kit SDK Boto3, nous vous recommandons d’ajouter toutes les dépendances de votre fonction à votre package de déploiement, même si elles sont incluses dans l’exécution. Pour plus d’informations, consultez la [Dépendances d’exécution en Python](https://docs.aws.amazon.com/lambda/latest/dg/python-package.html#python-package-dependencies).
```
mkdir package
pip install \
--platform manylinux2014_x86_64 \
--target=package \
--implementation cp \
--python-version 3.12 \
--only-binary=:all: --upgrade \
pillow boto3
```
La bibliothèque Pillow contient du code C/C\$1\$1. En utilisant les options `--platform manylinux_2014_x86_64` et `--only-binary=:all:`, pip téléchargera et installera une version de Pillow contenant des fichiers binaires précompilés compatibles avec le système d’exploitation Amazon Linux 2. Cela garantit que votre package de déploiement fonctionnera dans l’environnement d’exécution Lambda, quels que soient le système d’exploitation et l’architecture de votre ordinateur de création local.
1. Créez un fichier .zip contenant le code de votre application et les bibliothèques Pillow et Boto3. Sous Linux ou macOS, exécutez les commandes suivantes depuis votre interface de ligne de commande.
```
cd package
zip -r ../lambda_function.zip .
cd ..
zip lambda_function.zip lambda_function.py
```
Sous Windows, utilisez l’outil zip de votre choix pour créer le fichier `lambda_function.zip`. Assurez-vous que votre fichier `lambda_function.py` et les dossiers contenant vos dépendances sont installés à la racine du fichier .zip.
Vous pouvez également créer votre package de déploiement à l’aide d’un environnement virtuel Python. Consultez [Travailler avec des archives de fichiers .zip pour les fonctions Lambda Python](python-package.md)
------
## Créer la fonction Lambda
![\[\]](http://docs.aws.amazon.com/fr_fr/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_steps6.png)
Vous pouvez créer votre fonction Lambda à l'aide de la console Lambda AWS CLI ou de la console Lambda. Suivez les instructions correspondant à la langue de votre choix pour créer la fonction.
------
#### [ AWS Management Console ]
**Pour créer une fonction (console)**
Pour créer votre fonction Lambda à l’aide de la console, vous devez d’abord créer une fonction de base contenant du code « Hello world ». Vous remplacez ensuite ce code par votre propre code de fonction en chargeant le fichier .zip ou JAR que vous avez créé à l’étape précédente.
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 **Informations de base**, procédez comme suit :
1. Sous **Nom de la fonction**, saisissez `CreateThumbnail`.
1. Pour **Environnement d’exécution**, choisissez **Node.js 22.x** ou **Python 3.12** en fonction du langage que vous avez choisi pour votre fonction.
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 `LambdaS3Role` que vous avez créé précédemment.
1. Choisissez **Créer une fonction**.
**Pour charger le code de fonction (console)**
1. Dans le volet **Source du code**, choisissez **Charger à partir de**.
1. Choisissez **Fichier .zip**.
1. Choisissez **Charger**.
1. Dans le sélecteur de fichiers, sélectionnez votre fichier .zip et choisissez **Ouvrir**.
1. Choisissez **Enregistrer**.
------
#### [ AWS CLI ]
**Pour créer la fonction (AWS CLI)**
+ Exécutez la commande CLI pour la langue que vous avez choisie. Pour le `role` paramètre, assurez-vous de le remplacer `123456789012` par votre propre Compte AWS identifiant. Pour le paramètre `region`, remplacez `us-east-1` par la région dans laquelle vous avez créé vos compartiments Amazon S3.
+ Pour **Node.js**, exécutez la commande suivante depuis le répertoire contenant votre fichier `function.zip`.
```
aws lambda create-function --function-name CreateThumbnail \
--zip-file fileb://function.zip --handler index.handler --runtime nodejs24.x \
--timeout 10 --memory-size 1024 \
--role arn:aws:iam::123456789012:role/LambdaS3Role --region us-east-1
```
+ Pour **Python**, exécutez la commande suivante depuis le répertoire contenant votre fichier `lambda_function.zip`.
```
aws lambda create-function --function-name CreateThumbnail \
--zip-file fileb://lambda_function.zip --handler lambda_function.lambda_handler \
--runtime python3.14 --timeout 10 --memory-size 1024 \
--role arn:aws:iam::123456789012:role/LambdaS3Role --region us-east-1
```
------
## Configurer Amazon S3 pour invoquer la fonction
![\[\]](http://docs.aws.amazon.com/fr_fr/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_steps7.png)
Pour que votre fonction Lambda s’exécute lorsque vous chargez une image dans votre compartiment source, vous devez configurer un déclencheur pour votre fonction. Vous pouvez configurer le déclencheur Amazon S3 à l’aide de la console ou de la AWS CLI.
**Important**
Cette procédure configure le compartiment Amazon S3 pour qu’il invoque votre fonction chaque fois qu’un objet est créé dans le compartiment. Veillez à configurer cela uniquement pour le compartiment source. Si votre fonction Lambda crée des objets dans le même compartiment que celui qui l’invoque, votre fonction peut être [invoquée en continu dans une boucle](https://serverlessland.com/content/service/lambda/guides/aws-lambda-operator-guide/recursive-runaway). Cela peut entraîner la facturation de frais imprévus à votre Compte AWS charge.
------
#### [ AWS Management Console ]
**Pour configurer le déclencheur Amazon S3 (console)**
1. Ouvrez la [page Fonctions](https://console.aws.amazon.com/lambda/home#/functions) de la console Lambda et choisissez votre fonction (`CreateThumbnail`).
1. Choisissez **Add trigger (Ajouter déclencheur)**.
1. Sélectionnez **S3**.
1. Sous **Compartiment**, sélectionnez votre compartiment source.
1. Sous **Types d’événements**, sélectionnez **Tous les événements de création d’objets**.
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. Vous pouvez en savoir plus sur les modèles d’invocation récursive dans Lambda en lisant la rubrique [Modèles récursifs qui provoquent des fonctions Lambda incontrôlables dans Serverless Land](https://serverlessland.com/content/service/lambda/guides/aws-lambda-operator-guide/recursive-runaway).
1. Choisissez **Ajouter**.
Lorsque vous créez un déclencheur à l’aide de la console Lambda, ce dernier crée automatiquement une [politique basée sur une ressource](https://docs.aws.amazon.com/lambda/latest/dg/access-control-resource-based.html) pour donner au service que vous sélectionnez l’autorisation d’invoquer votre fonction.
------
#### [ AWS CLI ]
**Pour configurer le déclencheur Amazon S3 (AWS CLI)**
1. Pour que votre compartiment source Amazon S3 invoque votre fonction lorsque vous ajoutez un fichier image, vous devez d’abord configurer les autorisations pour votre fonction à l’aide d’une [politique basée sur une ressource](https://docs.aws.amazon.com/lambda/latest/dg/access-control-resource-based.html). Une déclaration de politique basée sur les ressources donne à d'autres personnes Services AWS l'autorisation d'invoquer votre fonction. Pour autoriser Amazon S3 à invoquer votre fonction, exécutez la commande CLI suivante. Assurez-vous de remplacer le `source-account` paramètre par votre propre Compte AWS identifiant et d'utiliser votre propre nom de compartiment source.
```
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
```
La politique que vous définissez à l’aide de cette commande permet à Amazon S3 d’invoquer votre fonction uniquement lorsqu’une action a lieu sur votre compartiment source.
**Note**
Bien que les noms des compartiments Amazon S3 soient globalement uniques, il est préférable de spécifier que le compartiment doit appartenir à votre compte lorsque vous utilisez des politiques basées sur les ressources. En effet, si vous supprimez un bucket, il est possible qu'un autre Compte AWS en crée un avec le même Amazon Resource Name (ARN).
1. Enregistrez le JSON suivant dans un fichier nommé `notification.json`. Lorsqu’il est appliqué à votre compartiment source, ce JSON configure le compartiment pour qu’il envoie une notification à votre fonction Lambda chaque fois qu’un nouvel objet est ajouté. Remplacez le Compte AWS numéro et, Région AWS dans la fonction Lambda, l'ARN par votre propre numéro de compte et votre propre région.
```
{
"LambdaFunctionConfigurations": [
{
"Id": "CreateThumbnailEventConfiguration",
"LambdaFunctionArn": "arn:aws:lambda:us-east-1:123456789012:function:CreateThumbnail",
"Events": [ "s3:ObjectCreated:Put" ]
}
]
}
```
1. Exécutez la commande CLI suivante pour appliquer les paramètres de notification du fichier JSON que vous avez créé à votre compartiment source. Remplacez `amzn-s3-demo-source-bucket` par le nom de votre propre compartiment source.
```
aws s3api put-bucket-notification-configuration --bucket amzn-s3-demo-source-bucket \
--notification-configuration file://notification.json
```
Pour en savoir plus sur la `put-bucket-notification-configuration` commande et l'`notification-configuration`option, consultez le manuel de *référence [put-bucket-notification-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/put-bucket-notification-configuration.html)des commandes de la AWS CLI*.
------
## Test de votre fonction Lambda à l’aide d’un événement fictif
![\[\]](http://docs.aws.amazon.com/fr_fr/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_steps8.png)
Avant de tester l’ensemble de votre configuration en ajoutant un fichier image à votre compartiment source Amazon S3, vous devez vérifier que votre fonction Lambda fonctionne correctement en l’invoquant avec un événement fictif. Un événement dans Lambda est un document au format JSON qui contient des données à traiter par votre fonction. Lorsque votre fonction est invoquée par Amazon S3, l’événement envoyé à votre fonction contient des informations telles que le nom du compartiment, l’ARN du compartiment et la clé de l’objet.
------
#### [ AWS Management Console ]
**Pour tester votre fonction Lambda à l’aide d’un événement fictif (console)**
1. Ouvrez la [page Fonctions](https://console.aws.amazon.com/lambda/home#/functions) de la console Lambda et choisissez votre fonction (`CreateThumbnail`).
1. Choisissez l’onglet **Test**.
1. Pour créer votre événement de test, dans le volet **Événement de test**, procédez comme suit :
1. Sous **Action d’événement de test**, sélectionnez **Créer un nouvel événement**.
1. Dans **Event name** (Nom de l’événement), saisissez **myTestEvent**.
1. Pour **Modèle**, sélectionnez **S3 Put**.
1. Remplacez les valeurs des paramètres suivants par vos propres valeurs.
+ Pour`awsRegion`, remplacez-le `us-east-1` par celui dans Région AWS lequel vous avez créé vos compartiments Amazon S3.
+ Pour `name`, remplacez `amzn-s3-demo-bucket` par le nom de votre propre compartiment source Amazon S3.
+ Pour `key`, remplacez `test%2Fkey` par le nom de fichier de l’objet de test que vous avez chargé dans votre compartiment source à l’étape [Charger une image de test dans votre compartiment source](#with-s3-tutorial-test-image).
```
{
"Records": [
{
"eventVersion": "2.0",
"eventSource": "aws:s3",
"awsRegion": "us-east-1",
"eventTime": "1970-01-01T00:00:00.000Z",
"eventName": "ObjectCreated:Put",
"userIdentity": {
"principalId": "EXAMPLE"
},
"requestParameters": {
"sourceIPAddress": "127.0.0.1"
},
"responseElements": {
"x-amz-request-id": "EXAMPLE123456789",
"x-amz-id-2": "EXAMPLE123/5678abcdefghijklambdaisawesome/mnopqrstuvwxyzABCDEFGH"
},
"s3": {
"s3SchemaVersion": "1.0",
"configurationId": "testConfigRule",
"bucket": {
"name": "amzn-s3-demo-bucket",
"ownerIdentity": {
"principalId": "EXAMPLE"
},
"arn": "arn:aws:s3:::amzn-s3-demo-bucket"
},
"object": {
"key": "test%2Fkey",
"size": 1024,
"eTag": "0123456789abcdef0123456789abcdef",
"sequencer": "0A1B2C3D4E5F678901"
}
}
}
]
}
```
1. Choisissez **Enregistrer**.
1. Dans le volet **Événement de test**, choisissez **Test**.
1. Pour vérifier que votre fonction a créé une version redimensionnée de votre image et l’a stockée dans votre compartiment Amazon S3 cible, procédez comme suit :
1. Ouvrez la [page Compartiments](https://console.aws.amazon.com/s3/buckets) de la console Amazon S3.
1. Choisissez votre compartiment cible et vérifiez que votre fichier redimensionné est répertorié dans le volet **Objets**.
------
#### [ AWS CLI ]
**Pour tester de votre fonction Lambda à l’aide d’un événement fictif (AWS CLI)**
1. Enregistrez le JSON suivant dans un fichier nommé `dummyS3Event.json`. Remplacez les valeurs des paramètres suivants par vos propres valeurs :
+ Pour`awsRegion`, remplacez-le `us-east-1` par celui dans Région AWS lequel vous avez créé vos compartiments Amazon S3.
+ Pour `name`, remplacez `amzn-s3-demo-bucket` par le nom de votre propre compartiment source Amazon S3.
+ Pour `key`, remplacez `test%2Fkey` par le nom de fichier de l’objet de test que vous avez chargé dans votre compartiment source à l’étape [Charger une image de test dans votre compartiment source](#with-s3-tutorial-test-image).
```
{
"Records": [
{
"eventVersion": "2.0",
"eventSource": "aws:s3",
"awsRegion": "us-east-1",
"eventTime": "1970-01-01T00:00:00.000Z",
"eventName": "ObjectCreated:Put",
"userIdentity": {
"principalId": "EXAMPLE"
},
"requestParameters": {
"sourceIPAddress": "127.0.0.1"
},
"responseElements": {
"x-amz-request-id": "EXAMPLE123456789",
"x-amz-id-2": "EXAMPLE123/5678abcdefghijklambdaisawesome/mnopqrstuvwxyzABCDEFGH"
},
"s3": {
"s3SchemaVersion": "1.0",
"configurationId": "testConfigRule",
"bucket": {
"name": "amzn-s3-demo-bucket",
"ownerIdentity": {
"principalId": "EXAMPLE"
},
"arn": "arn:aws:s3:::amzn-s3-demo-bucket"
},
"object": {
"key": "test%2Fkey",
"size": 1024,
"eTag": "0123456789abcdef0123456789abcdef",
"sequencer": "0A1B2C3D4E5F678901"
}
}
}
]
}
```
1. À partir du répertoire dans lequel vous avez enregistré votre fichier `dummyS3Event.json`, invoquez la fonction en exécutant la commande CLI suivante. Cette commande invoque votre fonction Lambda de manière synchrone en la spécifiant `RequestResponse` comme valeur du paramètre de type d’invocation. Pour en savoir plus sur l’invocation synchrone et asynchrone, consultez [Invocation de fonctions Lambda.](https://docs.aws.amazon.com/lambda/latest/dg/lambda-invocation.html)
```
aws lambda invoke --function-name CreateThumbnail \
--invocation-type RequestResponse --cli-binary-format raw-in-base64-out \
--payload file://dummyS3Event.json outputfile.txt
```
cli-binary-formatCette option est obligatoire si vous utilisez la version 2 du AWS CLI. Pour faire de ce paramètre le paramètre par défaut, exécutez `aws configure set cli-binary-format raw-in-base64-out`. Pour plus d’informations, veuillez consulter les [AWS CLI options de ligne de commande](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list).
1. Vérifiez que votre fonction a créé une version miniature de votre image et l’a enregistrée dans votre compartiment Amazon S3 cible. Exécutez la commande CLI suivante, en remplaçant `amzn-s3-demo-source-bucket-resized` par le nom de votre compartiment de destination.
```
aws s3api list-objects-v2 --bucket amzn-s3-demo-source-bucket-resized
```
Vous devez visualiser des résultats similaires à ce qui suit. Le paramètre `Key` indique le nom de fichier de votre fichier image redimensionné.
```
{
"Contents": [
{
"Key": "resized-HappyFace.jpg",
"LastModified": "2023-06-06T21:40:07+00:00",
"ETag": "\"d8ca652ffe83ba6b721ffc20d9d7174a\"",
"Size": 2633,
"StorageClass": "STANDARD"
}
]
}
```
------
## Tester votre fonction à l’aide du déclencheur Amazon S3
![\[\]](http://docs.aws.amazon.com/fr_fr/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_steps9.png)
Maintenant que vous avez confirmé que votre fonction Lambda fonctionne correctement, vous êtes prêt à tester votre configuration complète en ajoutant un fichier image à votre compartiment source Amazon S3. Lorsque vous ajoutez votre image au compartiment source, votre fonction Lambda doit être automatiquement invoquée. Votre fonction crée une version redimensionnée du fichier et la stocke dans votre compartiment cible.
------
#### [ AWS Management Console ]
**Pour tester votre fonction Lambda à l’aide du déclencheur Amazon S3 (console)**
1. Pour charger une image dans votre compartiment Amazon S3, procédez comme suit :
1. Ouvrez la page [Compartiments](https://console.aws.amazon.com/s3/buckets) de la console Amazon S3 et choisissez votre compartiment source.
1. Choisissez **Charger**.
1. Choisissez **Ajouter des fichiers** et utilisez le sélecteur de fichiers pour sélectionner le fichier image que vous souhaitez charger. Votre objet image peut être n’importe quel fichier .jpg ou .png.
1. Choisissez **Ouvrir**, puis **Charger**.
1. Vérifiez que Lambda a enregistré une version redimensionnée de votre fichier image dans votre compartiment cible en procédant comme suit :
1. Retournez à la page [Compartiments](https://console.aws.amazon.com/s3/buckets) de la console Amazon S3 et choisissez votre compartiment de destination.
1. Dans le volet **Objets**, vous devriez maintenant voir deux fichiers image redimensionnés, un pour chaque test de votre fonction Lambda. Pour télécharger votre image redimensionnée, sélectionnez le fichier, puis choisissez **Télécharger**.
------
#### [ AWS CLI ]
**Pour tester votre fonction Lambda à l’aide du déclencheur Amazon S3 (AWS CLI)**
1. À partir du répertoire contenant l’image que vous souhaitez charger, exécutez la commande CLI suivante. Remplacez le paramètre `--bucket` par le nom de votre compartiment source. Pour les paramètres `--key` et `--body`, utilisez le nom de fichier de votre image de test. Votre image de test peut être n’importe quel fichier .jpg ou .png.
```
aws s3api put-object --bucket amzn-s3-demo-source-bucket --key SmileyFace.jpg --body ./SmileyFace.jpg
```
1. Vérifiez que votre fonction a créé une version miniature de votre image et l’a enregistrée dans votre compartiment Amazon S3 cible. Exécutez la commande CLI suivante, en remplaçant `amzn-s3-demo-source-bucket-resized` par le nom de votre compartiment de destination.
```
aws s3api list-objects-v2 --bucket amzn-s3-demo-source-bucket-resized
```
Si votre fonction s’exécute correctement, vous obtiendrez un résultat similaire à celui qui suit. Votre compartiment cible doit désormais contenir deux fichiers redimensionnés.
```
{
"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"
}
]
}
```
------
## 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**
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).
**Suppression de la stratégie que vous avez créée**
1. Ouvrez la [page Policies (Stratégies)](https://console.aws.amazon.com/iam/home#/policies) de la console IAM.
1. Sélectionnez la politique que vous avez créée (**AWSLambdaS3Policy**).
1. Choisissez **Actions de stratégie**, **Supprimer**.
1. Sélectionnez **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**.