Didacticiel : Utilisation d'un déclencheur Amazon S3 pour créer des images miniatures - AWS Lambda
PrérequisCréation de deux compartiments Amazon S3Charger une image de test dans votre compartiment sourceCréer une stratégie d’autorisationsCréer un rôle d’exécutionCréer le package de déploiement de la fonctionCréer la fonction LambdaConfigurer Amazon S3 pour invoquer la fonctionTest de votre fonction Lambda à l’aide d’un événement fictifTester votre fonction à l'aide du déclencheur Amazon S3Nettoyage de vos ressources

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

Flux de données entre un compartiment S3, une fonction Lambda et un autre compartiment S3

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.

  2. Créez une fonction Lambda qui redimensionne une image et envoie une miniature vers un compartiment Amazon S3.

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

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

Prérequis

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

Pour vous inscrire à un Compte AWS

  1. Ouvrez l'https://portal.aws.amazon.com/billing/inscription.

  2. Suivez les instructions en ligne.

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

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

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

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

Sécurisez votre Utilisateur racine d'un compte AWS

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

    Pour obtenir de l‘aide pour vous connecter en utilisant l‘utilisateur racine, consultez Connexion en tant qu‘utilisateur racine dans le Guide de l‘utilisateur Connexion à AWS .

  2. Activez l'authentification multifactorielle (MFA) pour votre utilisateur root.

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

Création d'un utilisateur doté d'un accès administratif

  1. Activez IAM Identity Center.

    Pour obtenir des instructions, consultez Activation d’ AWS IAM Identity Center dans le Guide de l’utilisateur AWS IAM Identity Center .

  2. Dans IAM Identity Center, accordez un accès administratif à un utilisateur.

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

Connexion en tant qu‘utilisateur doté d'un accès administratif

  • Pour vous connecter avec votre utilisateur IAM Identity Center, utilisez l'URLidentifiant envoyé à votre adresse e-mail lorsque vous avez créé l'utilisateur IAM Identity Center.

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

Attribution d'un accès à d'autres utilisateurs

  1. Dans IAM Identity Center, créez un ensemble d'autorisations conforme à la meilleure pratique consistant à appliquer les autorisations du moindre privilège.

    Pour obtenir des instructions, consultez Création d’un ensemble d’autorisations dans le Guide de l’utilisateur AWS IAM Identity Center .

  2. Attribuez des utilisateurs à un groupe, puis attribuez un accès par authentification unique au groupe.

    Pour obtenir des instructions, consultez Ajout de groupes dans le Guide de l’utilisateur AWS IAM Identity Center .

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.

Création de deux compartiments Amazon S3

Première étape : créer des compartiments S3

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 page Compartiments de la console Amazon S3.

  2. Choisissez Create bucket (Créer un compartiment).

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

    1. Pour le nom du compartiment, saisissez un nom unique au monde qui respecte les règles de dénomination du compartiment Amazon S3. Les noms de compartiment peuvent contenir uniquement des lettres minuscules, des chiffres, de points (.) et des traits d’union (-).

    2. Pour Région AWS, choisissez la Région AWS la plus proche de votre emplacement géographique. Plus loin dans le didacticiel, vous devez créer votre fonction Lambda dans celui-ci Région AWS. Notez donc la région que vous avez choisie.

  4. Conservez les valeurs par défaut de toutes les autres options et choisissez Créer un compartiment.

  5. Répétez les étapes 1 à 4 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 CLI commande 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 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 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.

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

Étape suivante : télécharger un objet de test

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 laquelle JPG ou n'importe quel PNG fichier de votre choix.

AWS Management Console
Pour charger une image de test dans votre compartiment source (console)

  1. Ouvrez la page Compartiments de la console Amazon S3.

  2. Sélectionnez le compartiment source que vous avez créé à l'étape précédente.

  3. Sélectionnez Charger.

  4. Choisissez Ajouter des fichiers et utilisez le sélecteur de fichiers pour sélectionner l’objet que vous souhaitez charger.

  5. Choisissez Ouvrir, puis Charger.

AWS CLI
Pour charger une image de test dans votre compartiment source (AWS CLI)

  • Dans le répertoire contenant l'image que vous souhaitez télécharger, exécutez la CLI commande 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éer une stratégie d’autorisations

Étape suivante : créer une politique d'autorisation

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 de la console AWS Identity and Access Management (IAM).

  2. Choisissez Create Policy (Créer une politique).

  3. Choisissez l'JSONonglet, puis collez la politique personnalisée suivante dans l'JSONéditeur.

    {
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "logs:PutLogEvents",
                "logs:CreateLogGroup",
                "logs:CreateLogStream"
            ],
            "Resource": "arn:aws:logs:*:*:*"
        },
        {
            "Effect": "Allow",
            "Action": [
                "s3:GetObject"
            ],
            "Resource": "arn:aws:s3:::*/*"
        },
        {
            "Effect": "Allow",
            "Action": [
                "s3:PutObject"
            ],
            "Resource": "arn:aws:s3:::*/*"
        }
    ]
}

  4. Choisissez Suivant.

  5. Sous Détails de la politique, pour le Nom de la politique, saisissez LambdaS3Policy.

  6. Choisissez Create Policy (Créer une politique).

AWS CLI
Pour créer la politique (AWS CLI)

  1. Enregistrez ce qui suit JSON 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:::*/*"
        }
    ]
}

  2. Dans le répertoire dans lequel vous avez enregistré le document de JSON politique, exécutez la CLI commande suivante.

    aws iam create-policy --policy-name LambdaS3Policy --policy-document file://policy.json

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

Étape suivante : créer un rôle d'exécution

Un rôle d'exécution est un IAM rôle qui accorde à une fonction Lambda l'autorisation d'accès AWS services 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. Ouvrez la page Rôles de la console (IAM).

  2. Sélectionnez Créer un rôle.

  3. Pour Type d'entité fiable, sélectionnez AWS service, et pour Cas d'utilisation, sélectionnez Lambda.

  4. Choisissez Suivant.

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

    2. Dans les résultats de la recherche, cochez la case pour LambdaS3Policy.

    3. Choisissez Suivant.

  6. Sous Détails du rôle, pour le Nom du rôle entrez LambdaS3Role.

  7. Sélectionnez 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 ce qui suit JSON 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"
    }
  ]
}

  2. Dans le répertoire dans lequel vous avez enregistré le document de politique de JSON confiance, exécutez la CLI commande 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

  3. Pour joindre la politique d'autorisation que vous avez créée à l'étape précédente, exécutez la CLI commande suivante. Remplacez le Compte AWS numéro indiqué dans le contrat ARN 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

Étape suivante : créer le package de déploiement

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

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

  3. Enregistrez le code de fonction suivant dans un fichier nommé index.mjs. Assurez-vous de les us-east-1 remplacer par celui 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);
  };

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

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

  2. Dans le répertoire dans lequel vous avez créé votre lambda_function.py fichier, créez un nouveau répertoire nommé package et installez la bibliothèque Pillow (PIL) et le AWS SDK for Python (Boto3). Bien que le moteur d'exécution Lambda Python inclut une version du Boto3SDK, nous vous recommandons d'ajouter toutes les dépendances de votre fonction à votre package de déploiement, même si elles sont incluses dans le runtime. Pour plus d'informations, consultez la Dépendances d'exécution en Python.

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

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

Créer la fonction Lambda

Étape suivante : créer la fonction

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 téléchargeant le fichier the.zip ou JAR le fichier que vous avez créé à l'étape précédente.

  1. Ouvrez la page Functions (Fonctions) de la console Lambda.

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

    Image montrant le menu déroulant des régions dans la console Lambda

  3. Sélectionnez Create function (Créer une fonction).

  4. Choisissez Créer à partir de zéro.

  5. Sous Informations de base, procédez comme suit :

    1. Sous Nom de la fonction, saisissez CreateThumbnail.

    2. Pour Runtime, choisissez Node.js 20.x ou Python 3.12 en fonction du langage que vous avez choisi pour votre fonction.

    3. Pour Architecture, choisissez x86_64.

  6. Dans l’onglet Modifier le rôle d’exécution par défaut, procédez comme suit :

    1. Ouvrez l’onglet, puis choisissez Utiliser un rôle existant.

    2. Sélectionnez le LambdaS3Role que vous avez créé précédemment.

  7. Sélectionnez Create function (Créer une fonction).

Pour charger le code de fonction (console)

  1. Dans le volet Source du code, choisissez Charger à partir de.

  2. Choisissez Fichier .zip.

  3. Sélectionnez Charger.

  4. Dans le sélecteur de fichiers, sélectionnez votre fichier .zip et choisissez Ouvrir.

  5. Choisissez Save (Enregistrer).

AWS CLI
Pour créer la fonction (AWS CLI)

  • Exécutez la CLI commande correspondant à 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 nodejs20.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.12 --timeout 10 --memory-size 1024 \
--role arn:aws:iam::123456789012:role/LambdaS3Role --region us-east-1

Configurer Amazon S3 pour invoquer la fonction

Étape suivante : créer le déclencheur Amazon S3

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. 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 de la console Lambda et choisissez votre fonction (CreateThumbnail).

  2. Choisissez Add trigger (Ajouter déclencheur).

  3. Sélectionnez S3.

  4. Sous Compartiment, sélectionnez votre compartiment source.

  5. Sous Types d’événements, sélectionnez Tous les événements de création d’objets.

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

  7. 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 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. Une déclaration de politique basée sur les ressources donne à d'autres personnes AWS services l'autorisation d'invoquer votre fonction. Pour autoriser Amazon S3 à appeler votre fonction, exécutez la CLI commande 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).

  2. Enregistrez ce qui suit JSON dans un fichier nomménotification.json. Lorsqu'il est appliqué à votre compartiment source, cela 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 par votre propre numéro ARN de compte et votre propre région.

    {
"LambdaFunctionConfigurations": [
    {
      "Id": "CreateThumbnailEventConfiguration",
      "LambdaFunctionArn": "arn:aws:lambda:us-east-1:123456789012:function:CreateThumbnail",
      "Events": [ "s3:ObjectCreated:Put" ]
    }
  ]
}

  3. Exécutez la CLI commande suivante pour appliquer les paramètres de notification du JSON fichier 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-configurationoption, consultez le put-bucket-notification-configurationmanuel de référence des AWS CLI commandes.

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

Étape suivante : créer un événement factice

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. Dans Lambda, un événement est un document JSON formaté 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, le compartiment ARN 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 de la console Lambda et choisissez votre fonction (CreateThumbnail).

  2. Choisissez l’onglet Test.

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

    2. Dans Event name (Nom de l’événement), saisissez myTestEvent.

    3. Pour Modèle, sélectionnez S3 Put.

    4. Remplacez les valeurs des paramètres suivants par vos propres valeurs.

      • PourawsRegion, 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.

      {
  "Records": [
    {
      "eventVersion": "2.0",
      "eventSource": "aws:s3",
      "awsRegion": "us-east-1",
      "eventTime": "1970-01-01T00:00:00.000Z",
      "eventName": "ObjectCreated:Put",
      "userIdentity": {
        "principalId": "EXAMPLE"
      },
      "requestParameters": {
        "sourceIPAddress": "127.0.0.1"
      },
      "responseElements": {
        "x-amz-request-id": "EXAMPLE123456789",
        "x-amz-id-2": "EXAMPLE123/5678abcdefghijklambdaisawesome/mnopqrstuvwxyzABCDEFGH"
      },
      "s3": {
        "s3SchemaVersion": "1.0",
        "configurationId": "testConfigRule",
        "bucket": {
          "name": "amzn-s3-demo-bucket",
          "ownerIdentity": {
            "principalId": "EXAMPLE"
          },
          "arn": "arn:aws:s3:::amzn-s3-demo-bucket"
        },
        "object": {
          "key": "test%2Fkey",
          "size": 1024,
          "eTag": "0123456789abcdef0123456789abcdef",
          "sequencer": "0A1B2C3D4E5F678901"
        }
      }
    }
  ]
}

    5. Choisissez Save (Enregistrer).

  4. Dans le volet Événement de test, choisissez Test.

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

    2. 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 ce qui suit JSON dans un fichier nommédummyS3Event.json. Remplacez les valeurs des paramètres suivants par vos propres valeurs :

    • PourawsRegion, 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.

    {
  "Records": [
    {
      "eventVersion": "2.0",
      "eventSource": "aws:s3",
      "awsRegion": "us-east-1",
      "eventTime": "1970-01-01T00:00:00.000Z",
      "eventName": "ObjectCreated:Put",
      "userIdentity": {
        "principalId": "EXAMPLE"
      },
      "requestParameters": {
        "sourceIPAddress": "127.0.0.1"
      },
      "responseElements": {
        "x-amz-request-id": "EXAMPLE123456789",
        "x-amz-id-2": "EXAMPLE123/5678abcdefghijklambdaisawesome/mnopqrstuvwxyzABCDEFGH"
      },
      "s3": {
        "s3SchemaVersion": "1.0",
        "configurationId": "testConfigRule",
        "bucket": {
          "name": "amzn-s3-demo-bucket",
          "ownerIdentity": {
            "principalId": "EXAMPLE"
          },
          "arn": "arn:aws:s3:::amzn-s3-demo-bucket"
        },
        "object": {
          "key": "test%2Fkey",
          "size": 1024,
          "eTag": "0123456789abcdef0123456789abcdef",
          "sequencer": "0A1B2C3D4E5F678901"
        }
      }
    }
  ]
}

  2. Dans le répertoire dans lequel vous avez enregistré votre dummyS3Event.json fichier, appelez la fonction en exécutant la CLI commande 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.

    aws lambda invoke --function-name CreateThumbnail \
--invocation-type RequestResponse --cli-binary-format raw-in-base64-out \
--payload file://dummyS3Event.json outputfile.txt

    cli-binary-format Cette 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.

  3. 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 CLI commande suivante en la amzn-s3-demo-source-bucket-resized remplaçant par le nom de votre propre 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

Étape suivante : tester la fonction

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 de la console Amazon S3 et choisissez votre compartiment source.

    2. Sélectionnez Charger.

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

    4. Choisissez Ouvrir, puis Charger.

  2. 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 de la console Amazon S3 et choisissez votre compartiment de destination.

    2. 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. Dans le répertoire contenant l'image que vous souhaitez télécharger, exécutez la CLI commande 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

  2. 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 CLI commande suivante en la amzn-s3-demo-source-bucket-resized remplaçant par le nom de votre propre 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) de la console Lambda.

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

  3. Sélectionnez Actions, Supprimer.

  4. Saisissez delete 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 Politiques de la IAM console.

  2. Sélectionnez la politique que vous avez créée (AWSLambdaS3Policy).

  3. Choisissez Actions de stratégie, Supprimer.

  4. Sélectionnez Delete (Supprimer).

Pour supprimer le rôle d'exécution

  1. Ouvrez la page Rôles de la IAM console.

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

  3. Sélectionnez Delete (Supprimer).

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

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

  3. Sélectionnez Delete (Supprimer).

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

  5. Choisissez Supprimer le compartiment.