Tutorial: Verwenden eines Amazon-S3-Auslösers zum Erstellen von Miniaturbildern

So erstellen Sie die Amazon-S3-Buckets (Konsole)

1. Öffnen Sie die Seite Buckets der Amazon-S3-Konsole.

2. Wählen Sie Bucket erstellen aus.

3. Führen Sie unter Allgemeine Konfiguration die folgenden Schritte aus:

   1. Geben Sie für den Bucket-Namen einen global eindeutigen Namen ein, der den Regeln für die Bucket-Benennung von Amazon S3 entspricht. Bucket-Namen dürfen nur aus Kleinbuchstaben, Zahlen, Punkten (.) und Bindestrichen (-) bestehen.

   2. Wählen Sie unter AWS-Region die AWS-Region aus, die Ihrem geografischen Standort am nächsten ist. Später im Tutorial müssen Sie Ihre Lambda-Funktion in derselben erstellen. Notieren Sie sich also die Region AWS-Region, die Sie ausgewählt haben.

4. Belassen Sie alle anderen Optionen auf ihren Standardwerten und wählen Sie Bucket erstellen aus.

5. Wiederholen Sie die Schritte 1 bis 4, um Ihren Ziel-Bucket zu erstellen. Geben Sie unter Bucket-Name den Namen amzn-s3-demo-source-bucket-resized ein. amzn-s3-demo-source-bucket ist hierbei der Name des Quell-Buckets, den Sie soeben erstellt haben.

So erstellen Sie die Amazon-S3-Buckets (AWS CLI)

1. Führen Sie den folgenden CLI Befehl aus, um Ihren Quell-Bucket zu erstellen. Der gewählte Name für Ihren Bucket muss global eindeutig sein und den Regeln für die Benennung von Buckets für Amazon S3 entsprechen. Namen dürfen nur Kleinbuchstaben, Zahlen, Punkte (.) und Bindestriche (-) enthalten. Wählen Sie für region und LocationConstraint die AWS-Region aus, die Ihrem geografischen Standort am nächsten ist.

   aws s3api create-bucket --bucket amzn-s3-demo-source-bucket --region us-east-1 \
   --create-bucket-configuration LocationConstraint=us-east-1

   Später im Tutorial müssen Sie Ihre Lambda-Funktion im selben Verzeichnis AWS-Region wie in Ihrem Quell-Bucket erstellen. Notieren Sie sich also die Region, die Sie ausgewählt haben.

2. Führen Sie den folgenden Befehl aus, um Ihren Ziel-Bucket zu erstellen. Verwenden Sie für den Bucket-Namen amzn-s3-demo-source-bucket-resized. amzn-s3-demo-source-bucket ist hierbei der Name des Quell-Buckets, den Sie in Schritt 1 erstellt haben. Wählen Sie für region und dasselbe ausLocationConstraint, das AWS-Region Sie zur Erstellung Ihres Quell-Buckets verwendet haben.

   aws s3api create-bucket --bucket amzn-s3-demo-source-bucket-resized --region us-east-1 \
   --create-bucket-configuration LocationConstraint=us-east-1

So laden Sie ein Testbild in Ihren Quell-Bucket hoch (Konsole)

1. Öffnen Sie die Seite Buckets der Amazon-S3-Konsole.

2. Wählen Sie den Quell-Bucket aus, den Sie im vorherigen Schritt erstellt haben.

3. Klicken Sie auf Hochladen.

4. Wählen Sie Dateien hinzufügen aus und wählen Sie mit der Dateiauswahl das Objekt aus, das Sie hochladen möchten.

5. Wählen Sie Öffnen und anschließend Hochladen aus.

So laden Sie ein Testbild in Ihren Quell-Bucket hoch (AWS CLI)

• Führen Sie in dem Verzeichnis, das das Bild enthält, das Sie hochladen möchten, den folgenden CLI Befehl aus. Ersetzen Sie dabei den Parameter --bucket durch den Namen Ihres Quell-Buckets. Verwenden Sie für die Parameter --key und --body den Dateinamen Ihres Testbilds.

  aws s3api put-object --bucket amzn-s3-demo-source-bucket --key HappyFace.jpg --body ./HappyFace.jpg

So erstellen Sie die Richtlinie (Konsole)

1. Öffnen Sie die Seite Richtlinien der Konsole AWS Identity and Access Management (IAM).

2. Wählen Sie Create Policy (Richtlinie erstellen) aus.

3. Wählen Sie die JSONRegisterkarte und fügen Sie dann die folgende benutzerdefinierte Richtlinie in den JSON Editor ein.

   {
       "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. Wählen Sie Weiter.

5. Geben Sie unter Richtliniendetails für den Richtliniennamen LambdaS3Policy ein.

6. Wählen Sie Create Policy (Richtlinie erstellen) aus.

So erstellen Sie die Richtlinie (AWS CLI)

1. Speichern Sie Folgendes JSON in einer Datei mit dem Namenpolicy.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. Führen Sie in dem Verzeichnis, in dem Sie das JSON Richtliniendokument gespeichert haben, den folgenden CLI Befehl aus.

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

So erstellen Sie eine Ausführungsrolle und fügen Ihre Berechtigungsrichtlinie hinzu (Konsole)

1. Öffnen Sie die Rollenseite der Konsole (IAM).

2. Wählen Sie Rolle erstellen.

3. Wählen Sie unter Vertrauenswürdiger Entitätstyp die Option AWS-Service und unter Anwendungsfall die Option Lambda aus.

4. Wählen Sie Weiter.

5. Fügen Sie die Berechtigungsrichtlinie hinzu, die Sie im vorherigen Schritt erstellt haben:

   1. Geben Sie im Feld für die Richtliniensuche LambdaS3Policy ein.

   2. Aktivieren Sie in den Suchergebnissen das Kontrollkästchen für LambdaS3Policy.

   3. Wählen Sie Weiter.

6. Geben Sie unter Rollendetails im Feld Rollenname den Namen LambdaS3Role ein.

7. Wählen Sie Rolle erstellen.

So erstellen Sie eine Ausführungsrolle und fügen Ihre Berechtigungsrichtlinie an (AWS CLI)

1. Speichern Sie Folgendes JSON in einer Datei mit dem Namentrust-policy.json. Diese Vertrauensrichtlinie ermöglicht es Lambda, die Berechtigungen der Rolle zu verwenden, indem dem Dienstprinzipal die lambda.amazonaws.com Erlaubnis erteilt wird, die AssumeRole Aktion AWS Security Token Service (AWS STS) aufzurufen.

   {
     "Version": "2012-10-17",
     "Statement": [
       {
         "Effect": "Allow",
         "Principal": {
           "Service": "lambda.amazonaws.com"
         },
         "Action": "sts:AssumeRole"
       }
     ]
   }

2. Führen Sie in dem Verzeichnis, in dem Sie das Dokument mit der JSON Vertrauensrichtlinie gespeichert haben, den folgenden CLI Befehl aus, um die Ausführungsrolle zu erstellen.

   aws iam create-role --role-name LambdaS3Role --assume-role-policy-document file://trust-policy.json

3. Führen Sie den folgenden CLI Befehl aus, um die im vorherigen Schritt erstellte Berechtigungsrichtlinie anzuhängen. Ersetzen Sie die AWS-Konto Nummer in den Richtlinien ARN durch Ihre eigene Kontonummer.

   aws iam attach-role-policy --role-name LambdaS3Role --policy-arn arn:aws:iam::123456789012:policy/LambdaS3Policy

So erstellen Sie das Bereitstellungspaket (Node.js)

1. Erstellen Sie ein Verzeichnis namens lambda-s3 für Ihren Funktionscode und die Abhängigkeiten und navigieren Sie dorthin.

   mkdir lambda-s3
   cd lambda-s3

2. Erstellen Sie ein neues Node.js-Projekt mit npm. Um die im interaktiven Erlebnis bereitgestellten Standardoptionen zu akzeptieren, drücken Sie Enter.

   npm init

3. Speichern Sie den folgenden Funktionscode in einer lokalen Datei namens index.mjs: Stellen Sie sicher, dass Sie es durch die Buckets us-east-1 ersetzen, AWS-Region in denen Sie Ihre eigenen Quell- und Ziel-Buckets erstellt haben.

   // 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. Installieren Sie die Sharp-Bibliothek mithilfe von npm im Verzeichnis lambda-s3. Beachten Sie, dass die neueste Version von Sharp (0.33) nicht mit Lambda kompatibel ist. Installieren Sie für dieses Tutorial daher Version 0.32.6.

   npm install sharp@0.32.6

   Der npm-Befehl install erstellt ein Verzeichnis namens node_modules für Ihre Module. Nach diesem Schritt sollte Ihre Verzeichnisstruktur wie folgt aussehen:

   lambda-s3
   |- index.mjs
   |- node_modules
   |  |- base64js
   |  |- bl
   |  |- buffer
   ...
   |- package-lock.json
   |- package.json

5. Erstellen Sie ein ZIP-Bereitstellungspaket, das Ihren Funktionscode und die zugehörigen Abhängigkeiten enthält. Führen Sie unter macOS oder Linux den folgenden Befehl aus:

   zip -r function.zip .

   Verwenden Sie unter Windows Ihr bevorzugtes ZIP-Programm, um eine ZIP-Datei zu erstellen. Achten Sie darauf, dass sich die Dateien index.mjs, package.json und package-lock.json und das Verzeichnis node_modules im Stammverzeichnis der ZIP-Datei befinden.

So erstellen Sie das Bereitstellungspaket (Python)

1. Speichern Sie den Beispielcode als Datei mit dem Namen 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. Erstellen Sie in demselben Verzeichnis, in dem Sie Ihre lambda_function.py Datei erstellt haben, ein neues Verzeichnis mit dem Namen package und installieren Sie die Pillow (PIL) -Bibliothek und die AWS SDK for Python (Boto3). Obwohl die Lambda-Python-Laufzeit eine Version von Boto3 enthältSDK, empfehlen wir Ihnen, alle Abhängigkeiten Ihrer Funktion zu Ihrem Bereitstellungspaket hinzuzufügen, auch wenn sie in der Laufzeit enthalten sind. Weitere Informationen finden Sie in der Laufzeitabhängigkeiten in Python.

   mkdir package
   pip install \
   --platform manylinux2014_x86_64 \
   --target=package \
   --implementation cp \
   --python-version 3.12 \
   --only-binary=:all: --upgrade \
   pillow boto3

   Die Pillow-Bibliothek enthält Code in C/C++. Mithilfe der Optionen --platform manylinux_2014_x86_64 und --only-binary=:all: lädt pip eine Version von Pillow herunter und installiert sie, die vorkompilierte Binärdateien enthält, die mit dem Betriebssystem Amazon Linux 2 kompatibel sind. Dadurch wird sichergestellt, dass Ihr Bereitstellungspaket in der Lambda-Ausführungsumgebung funktioniert, unabhängig vom Betriebssystem und der Architektur Ihrer lokalen Build-Maschine.

3. Erstellen Sie eine ZIP-Datei, die Ihren Anwendungscode sowie die Pillow- und die Boto3-Bibliothek enthält. Führen Sie unter Linux oder MacOS die folgenden Befehle über Ihre Befehlszeilenschnittstelle aus:

   cd package
   zip -r ../lambda_function.zip .
   cd ..
   zip lambda_function.zip lambda_function.py

   Verwenden Sie unter Windows Ihr bevorzugtes ZIP-Tool, um die lambda_function.zip-Datei zu erstellen. Achten Sie darauf, dass sich die Datei lambda_function.py und die Ordner, die Ihre Abhängigkeiten enthalten, im Stammverzeichnis der ZIP-Datei befinden.

So erstellen Sie die Funktion (Konsole)

Wenn Sie Ihre Lambda-Funktion über die Konsole erstellen möchten, erstellen Sie zunächst eine Basisfunktion, die etwas Hello-World-Code enthält. Anschließend ersetzen Sie diesen Code durch Ihren eigenen Funktionscode, indem Sie the.zip oder eine JAR Datei hochladen, die Sie im vorherigen Schritt erstellt haben.

1. Öffnen Sie die Seite Funktionen der Lambda-Konsole.

2. Stellen Sie sicher, dass Sie in demselben Modus arbeiten, in dem AWS-Region Sie Ihren Amazon S3 S3-Bucket erstellt haben. Sie können Ihre Region mithilfe der Dropdown-Liste am oberen Bildschirmrand ändern.

   

3. Wählen Sie Funktion erstellen aus.

4. Wählen Sie Author from scratch aus.

5. Führen Sie unter Basic information (Grundlegende Informationen) die folgenden Schritte aus:

   1. Geben Sie für Function name (Funktionsname) CreateThumbnail ein.

   2. Wählen Sie für Runtime entweder Node.js 20.x oder Python 3.12, je nachdem, welche Sprache Sie für Ihre Funktion ausgewählt haben.

   3. Wählen Sie für Architektur x86_64 aus.

6. Gehen Sie auf der Registerkarte Standard-Ausführungsrolle ändern wie folgt vor:

   1. Erweitern Sie die Registerkarte und wählen Sie dann Verwenden einer vorhandenen Rolle aus.

   2. Wählen Sie die zuvor erstellte LambdaS3Role aus.

7. Wählen Sie Funktion erstellen aus.

So laden Sie den Funktionscode hoch (Konsole)

1. Wählen Sie im Bereich Codequelle die Option Hochladen von aus.

2. Wählen Sie die ZIP-Datei aus.

3. Klicken Sie auf Hochladen.

4. Wählen Sie in der Dateiauswahl Ihre ZIP-Datei und anschließend Öffnen aus.

5. Wählen Sie Save (Speichern) aus.

So erstellen Sie die Funktion (AWS CLI)

• Führen Sie den CLI Befehl für die von Ihnen gewählte Sprache aus. Stellen Sie sicher, dass Sie den role Parameter durch Ihre eigene AWS-Konto ID 123456789012 ersetzen. Ersetzen Sie für den Parameter region den Wert us-east-1 durch die Region, in der Sie Ihre Amazon-S3-Buckets erstellt haben.

  • Führen Sie für Node.js den folgenden Befehl in dem Verzeichnis aus, das die Datei function.zip enthält:

    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

  • Führen Sie für Python den folgenden Befehl in dem Verzeichnis aus, das die Datei lambda_function.zip enthält:

    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

So konfigurieren Sie den Amazon-S3-Auslöser (Konsole)

1. Öffnen Sie die Seite Funktionen der Lambda-Konsole und wählen Sie Ihre Funktion (CreateThumbnail) aus.

2. Wählen Sie Add trigger.

3. Wählen Sie S3 aus.

4. Wählen Sie unter Bucket Ihren Quell-Bucket aus.

5. Wählen Sie unter Ereignistypen die Option Alle Objekterstellungsereignisse aus.

6. Aktivieren Sie unter Rekursiver Aufruf das Kontrollkästchen, um zu bestätigen, dass die Verwendung desselben Amazon-S3-Buckets für die Ein- und Ausgabe nicht empfohlen wird. Weitere Informationen zu rekursiven Aufrufmustern in Lambda finden Sie bei Serverless Land unter Recursive patterns that cause run-away Lambda functions.

7. Wählen Sie Hinzufügen aus.

   Wenn Sie einen Auslöser über die Lambda-Konsole erstellen, erstellt Lambda automatisch eine ressourcenbasierte Richtlinie, um dem von Ihnen ausgewählten Dienst die Berechtigung zum Aufrufen Ihrer Funktion zu erteilen.

So konfigurieren Sie den Amazon-S3-Auslöser (AWS CLI)

1. Damit Ihr Amazon-S3-Quell-Bucket Ihre Funktion aufruft, wenn Sie eine Bilddatei hinzufügen, müssen Sie zunächst mithilfe einer ressourcenbasierten Richtlinie Berechtigungen für Ihre Funktion konfigurieren. Eine ressourcenbasierte Grundsatzerklärung erteilt anderen Personen die AWS-Services Erlaubnis, Ihre Funktion aufzurufen. Führen Sie den folgenden CLI Befehl aus, um Amazon S3 die Erlaubnis zu erteilen, Ihre Funktion aufzurufen. Achten Sie darauf, den source-account Parameter durch Ihre eigene AWS-Konto ID zu ersetzen und Ihren eigenen Quell-Bucket-Namen zu verwenden.

   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

   Die mit diesem Befehl definierte Richtlinie ermöglicht es Amazon S3 nur, Ihre Funktion aufzurufen, wenn eine Aktion in Ihrem Quell-Bucket ausgeführt wird.

   Anmerkung

   Namen von Amazon-S3-Buckets sind zwar global eindeutig, trotzdem empfiehlt es sich, bei der Verwendung ressourcenbasierter Richtlinien anzugeben, dass der Bucket zu Ihrem Konto gehören muss. Denn wenn Sie einen Bucket löschen, kann ein anderer AWS-Konto Bucket einen Bucket mit demselben Amazon-Ressourcennamen (ARN) erstellen.

2. Speichern Sie Folgendes JSON in einer Datei mit dem Namennotification.json. Wenn dies auf Ihren Quell-Bucket angewendet wird, JSON konfiguriert er den Bucket so, dass er jedes Mal, wenn ein neues Objekt hinzugefügt wird, eine Benachrichtigung an Ihre Lambda-Funktion sendet. Ersetzen Sie die AWS-Konto Nummer und AWS-Region in der Lambda-Funktion ARN durch Ihre eigene Kontonummer und Region.

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

3. Führen Sie den folgenden CLI Befehl aus, um die Benachrichtigungseinstellungen in der von Ihnen erstellten JSON Datei auf Ihren Quell-Bucket anzuwenden. Ersetzen Sie dabei amzn-s3-demo-source-bucket durch den Namen Ihres Quell-Buckets.

   aws s3api put-bucket-notification-configuration --bucket amzn-s3-demo-source-bucket \
   --notification-configuration file://notification.json

   Weitere Informationen zu dem put-bucket-notification-configuration Befehl und der notification-configuration Option finden Sie put-bucket-notification-configurationin der AWS CLIBefehlsreferenz.

So testen Sie Ihre Lambda-Funktion mit einem Dummy-Ereignis (Konsole)

1. Öffnen Sie die Seite Funktionen der Lambda-Konsole und wählen Sie Ihre Funktion (CreateThumbnail) aus.

2. Wählen Sie die Registerkarte Test.

3. Gehen Sie im Bereich Testereignis wie folgt vor, um Ihr Testereignis zu erstellen:

   1. Wählen Sie unter Testereignisaktion die Option Neues Ereignis erstellen aus.

   2. Geben Sie für Event name (Ereignisname) myTestEvent ein.

   3. Wählen Sie unter Vorlage die Option S3 Put aus.

   4. Ersetzen Sie die Werte für die folgenden Parameter durch Ihre eigenen Werte:

      • Ersetzen Sie für durch denawsRegion, in us-east-1 dem AWS-Region Sie Ihre Amazon S3 S3-Buckets erstellt haben.

      • Ersetzen Sie für name den Wert amzn-s3-demo-bucket durch den Namen Ihres eigenen Amazon-S3-Quell-Buckets.

      • Ersetzen Sie für key den Wert test%2Fkey durch den Dateinamen des Testobjekts, das Sie im Schritt Hochladen eines Testbilds in Ihren Quell-Bucket in Ihren Quell-Bucket hochgeladen haben.

      {
        "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. Wählen Sie Save (Speichern) aus.

4. Wählen Sie im Bereich Testereignis die Option Testen aus.

5. Gehen Sie wie folgt vor, um zu überprüfen, ob Ihre Funktion eine verkleinerte Version Ihres Bilds erstellt und in Ihrem Amazon-S3-Ziel-Bucket gespeichert hat:

   1. Öffnen Sie die Seite Buckets der Amazon-S3-Konsole.

   2. Wählen Sie Ihren Ziel-Bucket aus und vergewissern Sie sich, dass die Datei, deren Größe angepasst wurde, im Bereich Objekte vorhanden ist.

So testen Sie Ihre Lambda-Funktion mit einem Dummy-Ereignis (AWS CLI)

1. Speichern Sie Folgendes JSON in einer Datei mit dem NamendummyS3Event.json. Ersetzen Sie die Werte für die folgenden Parameter durch Ihre eigenen Werte:

   • Ersetzen Sie für durch denawsRegion, in us-east-1 dem AWS-Region Sie Ihre Amazon S3 S3-Buckets erstellt haben.

   • Ersetzen Sie für name den Wert amzn-s3-demo-bucket durch den Namen Ihres eigenen Amazon-S3-Quell-Buckets.

   • Ersetzen Sie für key den Wert test%2Fkey durch den Dateinamen des Testobjekts, das Sie im Schritt Hochladen eines Testbilds in Ihren Quell-Bucket in Ihren Quell-Bucket hochgeladen haben.

   {
     "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. Rufen Sie die Funktion in dem Verzeichnis auf, in dem Sie Ihre dummyS3Event.json Datei gespeichert haben, indem Sie den folgenden CLI Befehl ausführen. Dieser Befehl ruft Ihre Lambda-Funktion synchron auf, indem RequestResponse als Wert des Parameters „invocation-type“ angegeben wird. Weitere Informationen zu synchronen und asynchronen Aufrufen finden Sie unter Aufrufen von Lambda-Funktionen.

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

   Die cli-binary-format Option ist erforderlich, wenn Sie Version 2 von verwenden. AWS CLI Um dies zur Standardeinstellung zu machen, führen Sie aws configure set cli-binary-format raw-in-base64-out aus. Weitere Informationen finden Sie unter AWS CLI -unterstützte globale Befehlszeilenoptionen.

3. Vergewissern Sie sich, dass Ihre Funktion eine Miniaturversion Ihres Bilds erstellt und in Ihrem Amazon-S3-Ziel-Bucket gespeichert hat. Führen Sie den folgenden CLI Befehl aus und amzn-s3-demo-source-bucket-resized ersetzen Sie ihn durch den Namen Ihres eigenen Ziel-Buckets.

   aws s3api list-objects-v2 --bucket amzn-s3-demo-source-bucket-resized

   Die Ausgabe sollte in etwa wie folgt aussehen: Der Parameter Key zeigt den Dateinamen Ihrer verkleinerten Bilddatei an.

   {
       "Contents": [
           {
               "Key": "resized-HappyFace.jpg",
               "LastModified": "2023-06-06T21:40:07+00:00",
               "ETag": "\"d8ca652ffe83ba6b721ffc20d9d7174a\"",
               "Size": 2633,
               "StorageClass": "STANDARD"
           }
       ]
   }

So testen Sie Ihre Lambda-Funktion unter Verwendung des Amazon-S3-Auslösers (Konsole)

1. Gehen Sie wie folgt vor, um ein Bild in Ihren Amazon-S3-Bucket hochzuladen:

   1. Öffnen Sie die Seite Buckets der Amazon-S3-Konsole und wählen Sie Ihren Quell-Bucket aus.

   2. Klicken Sie auf Hochladen.

   3. Wählen Sie Dateien hinzufügen und anschließend über die Dateiauswahl die Bilddatei aus, die Sie hochladen möchten. Ihr Bildobjekt kann eine beliebige JPG- oder PNG-Datei sein.

   4. Wählen Sie Öffnen und anschließend Hochladen aus.

2. Vergewissern Sie sich, dass Lambda eine verkleinerte Version Ihrer Bilddatei in Ihrem Ziel-Bucket gespeichert hat:

   1. Navigieren Sie wieder zur Seite Buckets der Amazon-S3-Konsole und wählen Sie Ihren Ziel-Bucket aus.

   2. Im Bereich Objekte sollten jetzt zwei verkleinerte Bilddateien angezeigt werden (jeweils eine aus den beiden Tests Ihrer Lambda-Funktion). Wählen Sie zum Herunterladen Ihres verkleinerten Bilds die Datei und anschließend Herunterladen aus.

So testen Sie Ihre Lambda-Funktion unter Verwendung des Amazon-S3-Auslösers (AWS CLI)

1. Führen Sie in dem Verzeichnis, das das Bild enthält, das Sie hochladen möchten, den folgenden CLI Befehl aus. Ersetzen Sie dabei den Parameter --bucket durch den Namen Ihres Quell-Buckets. Verwenden Sie für die Parameter --key und --body den Dateinamen Ihres Testbilds. Ihr Testbild kann eine beliebige JPG- oder PNG-Datei sein.

   aws s3api put-object --bucket amzn-s3-demo-source-bucket --key SmileyFace.jpg --body ./SmileyFace.jpg

2. Vergewissern Sie sich, dass Ihre Funktion eine Miniaturversion Ihres Bilds erstellt und in Ihrem Amazon-S3-Ziel-Bucket gespeichert hat. Führen Sie den folgenden CLI Befehl aus und amzn-s3-demo-source-bucket-resized ersetzen Sie ihn durch den Namen Ihres eigenen Ziel-Buckets.

   aws s3api list-objects-v2 --bucket amzn-s3-demo-source-bucket-resized

   Wenn Ihre Funktion erfolgreich ausgeführt wird, erhalten Sie eine Ausgabe wie die folgende. Ihr Ziel-Bucket sollte jetzt zwei verkleinerte Dateien enthalten.

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