Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Verarbeitung von Amazon-S3-Ereignisbenachrichtigungen mit Lambda
Sie können Lambda verwenden, um [Ereignisbenachrichtigungen](https://docs.aws.amazon.com/AmazonS3/latest/userguide/NotificationHowTo.html) von Amazon Simple Storage Service zu verarbeiten. Amazon S3 kann ein Ereignis an eine Lambda-Funktion senden, wenn ein Objekt erstellt oder gelöscht wird. Sie konfigurieren Benachrichtigungseinstellungen für einen Bucket und erteilen die Amazon-S3-Berechtigung zum Aufrufen einer Funktion in der ressourcenbasierten Berechtigungsrichtlinie der Funktion.
**Warnung**
Wenn Ihre Lambda-Funktion den gleichen Bucket verwendet, der sie auslöst, könnte dies dazu führen, dass die Funktion in einer Schleife ausgeführt wird. Wenn der Bucket z. B. eine Funktion immer dann auslöst, wenn ein Objekt hochgeladen wird, und die Funktion ein Objekt in den Bucket hochlädt, löst die Funktion sich indirekt selbst aus. Um dies zu vermeiden, verwenden Sie zwei Buckets oder konfigurieren Sie den Auslöser so, dass er nur für einen Präfix gilt, der für eingehende Objekte verwendet wird.
Amazon S3 ruft Ihre Funktion [asynchron](invocation-async.md) mit einem Ereignis auf, das Details über das Objekt enthält. Das folgende Beispiel zeigt ein Ereignis, das Amazon S3 gesendet hat, als ein Bereitstellungspaket in Amazon S3 hochgeladen wurde.
**Example Amazon-S3-Benachrichtigungsereignis**
```
{
"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"
}
}
}
]
}
```
Um Ihre Funktion aufzurufen, benötigt Amazon S3 die Berechtigung von der [ressourcenbasierten Richtlinie](access-control-resource-based.md) der Funktion. Wenn Sie einen Amazon-S3-Auslöser in der Lambda-Konsole konfigurieren, ändert die Konsole die ressourcenbasierte Richtlinie so, dass Amazon S3 die Funktion aufrufen kann, wenn der Bucket-Name und die Konto-ID übereinstimmen. Wenn Sie die Benachrichtigung in Amazon S3 konfigurieren, verwenden Sie die Lambda-API, um die Richtlinie zu aktualisieren. Sie können auch die Lambda-API verwenden, um einem anderen Konto Berechtigungen zu erteilen oder die Berechtigung auf einen bestimmten Alias zu beschränken.
Wenn Ihre Funktion das AWS SDK zur Verwaltung von Amazon S3 S3-Ressourcen verwendet, benötigt sie in ihrer [Ausführungsrolle](lambda-intro-execution-role.md) auch Amazon S3 S3-Berechtigungen.
**Topics**
+ [Tutorial: Verwenden eines Amazon-S3-Auslösers zum Aufrufen einer Lambda-Funktion](with-s3-example.md)
+ [Tutorial: Verwenden eines Amazon-S3-Auslösers zum Erstellen von Miniaturbildern](with-s3-tutorial.md)
# Tutorial: Verwenden eines Amazon-S3-Auslösers zum Aufrufen einer Lambda-Funktion
In diesem Tutorial verwenden Sie die Konsole, um eine Lambda-Funktion zu erstellen und einen Auslöser für einen Amazon-Simple-Storage-Service-Bucket (Amazon-S3-Bucket) zu konfigurieren. Jedes Mal, wenn Sie Ihrem Amazon S3 S3-Bucket ein Objekt hinzufügen, wird Ihre Funktion ausgeführt und der Objekttyp wird an Amazon CloudWatch Logs ausgegeben.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/services-s3-example/s3_tut_config.png)
Dieses Tutorial zeigt, wie man:
1. Erstellen Sie einen Amazon-S3-Bucket.
1. Erstellen Sie eine Lambda-Funktion, die den Objekttyp von Objekten in einem Amazon-S3-Bucket ausgibt.
1. Konfigurieren Sie einen Lambda-Auslöser, der Ihre Funktion aufruft, wenn Objekte in Ihren Bucket hochgeladen werden.
1. Testen Sie Ihre Funktion, zuerst mit einem Dummy-Ereignis und dann mit dem Auslöser.
Durch das Ausführen dieser Schritte erfahren Sie, wie Sie eine Lambda-Funktion so konfigurieren, dass sie ausgeführt wird, wenn Objekte einem Amazon-S3-Bucket hinzugefügt oder daraus gelöscht werden. Sie können dieses Tutorial abschließen, indem Sie nur die AWS-Managementkonsole verwenden.
## Erstellen Sie einen Amazon S3 S3-Bucket
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/services-s3-example/s3trigger_tut_steps1.png)
**So erstellen Sie einen Amazon-S3-Bucket**
1. Öffnen Sie die [Amazon-S3-Konsole](https://console.aws.amazon.com/s3) und wählen Sie die Seite **Allzweck-Buckets** aus.
1. Wählen Sie den aus, der Ihrem geografischen Standort AWS-Region am nächsten liegt. Sie können Ihre Region mithilfe der Dropdown-Liste am oberen Bildschirmrand ändern. Später im Tutorial müssen Sie eine Lambda-Funktion in derselben Region erstellen.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/console_region_select.png)
1. Wählen Sie **Create Bucket** (Bucket erstellen) aus.
1. Führen Sie unter **Allgemeine Konfiguration** die folgenden Schritte aus:
1. Stellen Sie sicher, dass für **Bucket-Typ** die Option **Allzweck** ausgewählt ist.
1. Geben Sie für den **Bucket-Namen** einen global eindeutigen Namen ein, der den [Regeln für die Bucket-Benennung](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucketnamingrules.html) von Amazon S3 entspricht. Bucket-Namen dürfen nur aus Kleinbuchstaben, Zahlen, Punkten (.) und Bindestrichen (-) bestehen.
1. Belassen Sie alle anderen Optionen auf ihren Standardwerten und wählen Sie **Bucket erstellen** aus.
## Hochladen eines Testobjekts in Ihren Bucket
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/services-s3-example/s3trigger_tut_steps2.png)
**Hochladen eines Testobjekts**
1. Öffnen Sie die [Buckets-Seite](https://console.aws.amazon.com/s3/buckets) der Amazon-S3-Konsole und wählen Sie den Bucket aus, den Sie im vorherigen Schritt erstellt haben.
1. Klicken Sie auf **Hochladen**.
1. Wählen Sie **Dateien hinzufügen** aus und wählen Sie das Objekt, das Sie hochladen möchten. Sie können eine beliebige Datei auswählen (z. B. `HappyFace.jpg`).
1. Wählen Sie **Öffnen** und anschließend **Hochladen** aus.
Im weiteren Verlauf des Tutorials werden Sie Ihre Lambda-Funktion mit diesem Objekt testen.
## Erstellen einer Berechtigungsrichtlinie
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/services-s3-example/s3trigger_tut_steps3.png)
Erstellen Sie eine Berechtigungsrichtlinie, die es Lambda ermöglicht, Objekte aus einem Amazon S3 S3-Bucket abzurufen und in Amazon CloudWatch Logs zu schreiben.
**So erstellen Sie die Richtlinie**
1. Öffnen Sie die Seite [Richtlinien](https://console.aws.amazon.com/iam/home#/policies) in der IAM-Konsole.
1. Wählen Sie **Richtlinie erstellen** aus.
1. Wählen Sie die Registerkarte **JSON** aus und kopieren Sie dann die folgende benutzerdefinierte JSON-Richtlinie in den JSON-Editor.
------
#### [ 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. Wählen Sie **Next: Tags** (Weiter: Tags) aus.
1. Klicken Sie auf **Weiter: Prüfen**.
1. Geben Sie unter **Review policy (Richtlinie prüfen) ** für den Richtlinien-**Namen** **s3-trigger-tutorial** ein.
1. Wählen Sie **Richtlinie erstellen** aus.
## Erstellen einer Ausführungsrolle
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/services-s3-example/s3trigger_tut_steps4.png)
Eine [Ausführungsrolle](lambda-intro-execution-role.md) ist eine AWS Identity and Access Management (IAM-) Rolle, die einer Lambda-Funktion Zugriffsberechtigungen AWS-Services und Ressourcen gewährt. In diesem Schritt erstellen Sie eine Ausführungsrolle unter Verwendung der Berechtigungsrichtlinie, die Sie im vorherigen Schritt erstellt haben.
**So erstellen Sie eine Ausführungsrolle und fügen Ihre benutzerdefinierte Berechtigungsrichtlinie hinzu**
1. Öffnen Sie die Seite [Roles (Rollen)](https://console.aws.amazon.com/iam/home#/roles) in der IAM-Konsole.
1. Wählen Sie **Rolle erstellen** aus.
1. Wählen Sie als Typ der vertrauenswürdigen Entität **AWS -Service** und dann als Anwendungsfall **Lambda** aus.
1. Wählen Sie **Weiter** aus.
1. Geben Sie im Feld für die Richtliniensuche **s3-trigger-tutorial** ein.
1. Wählen Sie in den Suchergebnissen die von Ihnen erstellte Richtlinie (`s3-trigger-tutorial`) und dann die Option **Next** (Weiter) aus.
1. Geben Sie unter **Role details** (Rollendetails) für den **Role name** (Rollennamen) **lambda-s3-trigger-role** ein und wählen Sie dann **Create role** (Rolle erstellen) aus.
## So erstellen Sie die Lambda-Funktion:
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/services-s3-example/s3trigger_tut_steps5.png)
Erstellen Sie mit der Python 3.14-Laufzeit eine Lambda-Funktion in der Konsole.
**So erstellen Sie die Lambda-Funktion:**
1. Öffnen Sie die Seite [Funktionen](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole.
1. 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 oben auf dem Bildschirm ändern.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/console_region_select.png)
1. Wählen Sie **Funktion erstellen**.
1. Wählen Sie **Ohne Vorgabe erstellen** aus.
1. Führen Sie unter **Basic information** (Grundlegende Informationen) die folgenden Schritte aus:
1. Geben Sie unter **Funktionsname** `s3-trigger-tutorial` ein.
1. Wählen Sie für **Runtime** **Python 3.14**.
1. Wählen Sie für **Architektur** **x86\$164** aus.
1. 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.
1. Wählen Sie die zuvor erstellte `lambda-s3-trigger-role` aus.
1. Wählen Sie **Funktion erstellen**.
## Bereitstellen des Funktionscodes
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/services-s3-example/s3trigger_tut_steps6.png)
Dieses Tutorial verwendet die Python 3.14-Laufzeit, aber wir haben auch Beispielcodedateien für andere Laufzeiten bereitgestellt. Sie können die Registerkarte im folgenden Feld auswählen, um den Code für die gewünschte Laufzeit anzusehen.
Die Lambda-Funktion ruft den Schlüsselnamen des hochgeladenen Objekts und den Namen des Buckets aus dem `event`-Parameter ab, den sie von Amazon S3 erhält. Die Funktion verwendet dann die Methode [get\$1object](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/s3/client/get_object.html) von, AWS SDK für Python (Boto3) um die Metadaten des Objekts abzurufen, einschließlich des Inhaltstyps (MIME-Typ) des hochgeladenen Objekts.
**So stellen Sie den Funktionscode bereit**
1. Wählen Sie im folgenden Feld die Registerkarte **Python** und kopieren Sie den Code.
------
#### [ .NET ]
**SDK für .NET**
Es gibt noch mehr dazu. GitHub Das vollständige Beispiel sowie eine Anleitung zum Einrichten und Ausführen finden Sie im Repository mit [Serverless-Beispielen](https://github.com/aws-samples/serverless-snippets/tree/main/integration-s3-to-lambda).
Nutzen eines S3-Ereignisses mit Lambda unter Verwendung von .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 ]
**SDK für Go V2**
Es gibt noch mehr GitHub. Das vollständige Beispiel sowie eine Anleitung zum Einrichten und Ausführen finden Sie im Repository mit [Serverless-Beispielen](https://github.com/aws-samples/serverless-snippets/tree/main/integration-s3-to-lambda).
Nutzen eines S3-Ereignisses mit Lambda unter Verwendung von 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 für Java 2.x**
Es gibt noch mehr GitHub. Das vollständige Beispiel sowie eine Anleitung zum Einrichten und Ausführen finden Sie im Repository mit [Serverless-Beispielen](https://github.com/aws-samples/serverless-snippets/tree/main/integration-s3-to-lambda).
Nutzen eines S3-Ereignisses mit Lambda unter Verwendung von Java
```
// 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 für JavaScript (v3)**
Es gibt noch mehr dazu GitHub. Das vollständige Beispiel sowie eine Anleitung zum Einrichten und Ausführen finden Sie im Repository mit [Serverless-Beispielen](https://github.com/aws-samples/serverless-snippets/tree/main/integration-s3-to-lambda).
Konsumieren eines S3-Ereignisses mit Lambda unter Verwendung 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);
}
};
```
Konsumieren eines S3-Ereignisses mit Lambda unter Verwendung 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 ]
**SDK für PHP**
Es gibt noch mehr dazu. GitHub Das vollständige Beispiel sowie eine Anleitung zum Einrichten und Ausführen finden Sie im Repository mit [Serverless-Beispielen](https://github.com/aws-samples/serverless-snippets/tree/main/integration-s3-to-lambda).
Nutzen eines S3-Ereignisses mit Lambda unter Verwendung von 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 ]
**SDK für Python (Boto3)**
Es gibt noch mehr GitHub. Das vollständige Beispiel sowie eine Anleitung zum Einrichten und Ausführen finden Sie im Repository mit [Serverless-Beispielen](https://github.com/aws-samples/serverless-snippets/tree/main/integration-s3-to-lambda).
Nutzen eines S3-Ereignisses mit Lambda unter Verwendung von 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 ]
**SDK für Ruby**
Es gibt noch mehr GitHub. Das vollständige Beispiel sowie eine Anleitung zum Einrichten und Ausführen finden Sie im Repository mit [Serverless-Beispielen](https://github.com/aws-samples/serverless-snippets/tree/main/integration-s3-to-lambda).
Nutzen eines S3-Ereignisses mit Lambda unter Verwendung von 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 für Rust**
Es gibt noch mehr dazu GitHub. Das vollständige Beispiel sowie eine Anleitung zum Einrichten und Ausführen finden Sie im Repository mit [Serverless-Beispielen](https://github.com/aws-samples/serverless-snippets/tree/main/integration-s3-to-lambda).
Nutzen eines S3-Ereignisses mit Lambda unter Verwendung von 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. Fügen Sie den Code im **Code-Quell**bereich der Lambda-Konsole in den Code-Editor ein und ersetzen Sie dabei den von Lambda erstellten Code.
1. Wählen Sie im Abschnitt **DEPLOY** die Option **Deploy** aus, um den Code Ihrer Funktion zu aktualisieren:
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png)
## Erstellen des Amazon-S3-Auslösers
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/services-s3-example/s3trigger_tut_steps7.png)
**Erstellen des Amazon-S3-Auslösers**
1. Wählen Sie im Bereich **Function overview (Funktionsübersicht)** die Option **Add trigger (Auslöser hinzufügen)**.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/overview-trigger.png)
1. Wählen Sie **S3** aus.
1. Wählen Sie unter **Bucket** den Bucket aus, den Sie zuvor im Tutorial erstellt haben.
1. Vergewissern Sie sich, dass unter **Ereignistypen** die Option **Alle Ereignisse zur Objekterstellung** ausgewählt ist.
1. 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.
1. Wählen Sie **Hinzufügen** aus.
**Anmerkung**
Wenn Sie einen Amazon-S3-Trigger für eine Lambda-Funktion mithilfe der Lambda-Konsole erstellen, konfiguriert Amazon S3 eine [Ereignisbenachrichtigung](https://docs.aws.amazon.com/AmazonS3/latest/userguide/EventNotifications.html) für den von Ihnen angegebenen Bucket. Bevor diese Ereignisbenachrichtigung konfiguriert wird, führt Amazon S3 eine Reihe von Prüfungen durch, um zu bestätigen, dass das Ereignisziel existiert und die erforderlichen IAM-Richtlinien hat. Amazon S3 führt diese Tests auch bei allen anderen für diesen Bucket konfigurierten Ereignisbenachrichtigungen durch.
Wenn der Bucket zuvor Ereignisziele für Ressourcen konfiguriert hat, die nicht mehr existieren oder für Ressourcen, die nicht über die erforderlichen Berechtigungsrichtlinien verfügen, kann Amazon S3 aufgrund dieser Prüfung keine neue Ereignisbenachrichtigung erstellen. Es wird die folgende Fehlermeldung angezeigt, die besagt, dass Ihr Auslöser nicht erstellt werden konnte:
```
An error occurred when creating the trigger: Unable to validate the following destination configurations.
```
Dieser Fehler kann auftreten, wenn Sie zuvor einen Auslöser für eine andere Lambda-Funktion konfiguriert haben, die denselben Bucket verwendet und Sie die Funktion inzwischen gelöscht oder ihre Berechtigungsrichtlinien geändert haben.
## Testen Ihrer Lambda-Funktion mit einem Dummy-Ereignis
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/services-s3-example/s3trigger_tut_steps8.png)
**So testen Sie die Lambda-Funktion mit einem Dummy-Ereignis**
1. Wählen Sie auf der Konsolenseite für Ihre Funktion die Registerkarte **Test** aus.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/test-tab.png)
1. Geben Sie für **Event name (Ereignisname)** `MyTestEvent` ein.
1. Fügen Sie im **Event-JSON** das folgende Testereignis ein. Achten Sie darauf, diese Werte zu ersetzen:
+ Ersetzen Sie `us-east-1` durch die Region, in der Sie den Amazon-S3-Bucket erstellt haben.
+ Ersetzen Sie beide Vorkommen von `amzn-s3-demo-bucket` durch den Namen Ihres eigenen Amazon-S3-Buckets.
+ Ersetzen Sie `test%2FKey` durch den Namen des Testobjekts, das Sie zuvor in Ihren Bucket hochgeladen haben (z. B.`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. Wählen Sie **Speichern**.
1. Wählen Sie **Test** aus.
1. Wenn Ihre Funktion erfolgreich ausgeführt wird, wird auf der Registerkarte **Ausführungsergebnisse** eine Ausgabe angezeigt, die der folgenden ähnelt.
```
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
```
### Testen der Lambda-Funktion mit dem Amazon-S3-Auslöser
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/services-s3-example/s3trigger_tut_steps9.png)
Um Ihre Funktion mit dem konfigurierten Auslöser zu testen, können Sie unter Verwendung der Konsole ein Objekt in Ihren Amazon-S3-Bucket hochladen. Um zu überprüfen, ob Ihre Lambda-Funktion wie erwartet ausgeführt wurde, verwenden Sie CloudWatch Logs, um die Ausgabe Ihrer Funktion einzusehen.
**So laden Sie Objekte in Ihren Amazon-S3-Bucket hoch**
1. Öffnen Sie die [Buckets](https://console.aws.amazon.com/s3/buckets)-Seite der Amazon-S3-Konsole und wählen Sie den Bucket aus, den Sie zuvor erstellt haben.
1. Klicken Sie auf **Upload**.
1. Wählen Sie **Dateien hinzufügen** aus und wählen Sie mit der Dateiauswahl ein Objekt aus, das Sie hochladen möchten. Bei diesem Objekt kann es sich um eine beliebige von Ihnen ausgewählte Datei handeln.
1. Wählen Sie **Öffnen** und anschließend **Hochladen** aus.
**Um den Funktionsaufruf mithilfe von Logs zu überprüfen CloudWatch**
1. Öffnen Sie die [CloudWatch-Konsole](https://console.aws.amazon.com/cloudwatch/home).
1. Stellen Sie sicher, dass Sie in derselben Umgebung arbeiten, in der AWS-Region Sie Ihre Lambda-Funktion erstellt haben. Sie können Ihre Region mithilfe der Dropdown-Liste oben auf dem Bildschirm ändern.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/console_region_select.png)
1. Wählen Sie **Protokolle** und anschließend **Protokollgruppen** aus.
1. Wählen Sie die Protokollgruppe für Ihre Funktion (`/aws/lambda/s3-trigger-tutorial`) aus.
1. Wählen Sie im Bereich **Protokollstreams** den neuesten Protokollstream aus.
1. Wenn Ihre Funktion als Reaktion auf Ihren Amazon-S3-Auslöser korrekt aufgerufen wurde, erhalten Sie eine Ausgabe, die der folgenden ähnelt. Welchen `CONTENT TYPE` Sie sehen, hängt von der Art der Datei ab, die Sie in Ihren Bucket hochgeladen haben.
```
2022-05-09T23:17:28.702Z 0cae7f5a-b0af-4c73-8563-a3430333cc10 INFO CONTENT TYPE: image/jpeg
```
## Bereinigen Ihrer Ressourcen
Sie können jetzt die Ressourcen, die Sie für dieses Tutorial erstellt haben, löschen, es sei denn, Sie möchten sie behalten. Durch das Löschen von AWS Ressourcen, die Sie nicht mehr verwenden, vermeiden Sie unnötige Kosten für Ihre AWS-Konto.
**So löschen Sie die Lambda-Funktion:**
1. Öffnen Sie die Seite [Funktionen](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole.
1. Wählen Sie die Funktion aus, die Sie erstellt haben.
1. Wählen Sie **Aktionen**, **Löschen** aus.
1. Geben Sie **confirm** in das Texteingabefeld ein und wählen Sie **Delete** (Löschen) aus.
**So löschen Sie die Ausführungsrolle**
1. Öffnen Sie die Seite [Roles](https://console.aws.amazon.com/iam/home#/roles) in der IAM-Konsole.
1. Wählen Sie die von Ihnen erstellte Ausführungsrolle aus.
1. Wählen Sie **Löschen** aus.
1. Geben Sie den Namen der Rolle in das Texteingabefeld ein und wählen Sie **Delete** (Löschen) aus.
**So löschen Sie den S3-Bucket:**
1. Öffnen Sie die [Amazon S3-Konsole](https://console.aws.amazon.com//s3/home#).
1. Wählen Sie den Bucket aus, den Sie erstellt haben.
1. Wählen Sie **Löschen** aus.
1. Geben Sie den Namen des Buckets in das Texteingabefeld ein.
1. Wählen Sie **Bucket löschen** aus.
## Nächste Schritte
In [Tutorial: Verwenden eines Amazon-S3-Auslösers zum Erstellen von Miniaturbildern](with-s3-tutorial.md) ruft der Amazon-S3-Auslöser eine Funktion auf, die für jede Bilddatei, die in einen Bucket hochgeladen wird, ein Miniaturbild erstellt. Dieses Tutorial erfordert ein gewisses Maß AWS an Wissen über Lambda-Domänen. Es zeigt, wie Ressourcen mithilfe von AWS Command Line Interface (AWS CLI) erstellt werden und wie ein Bereitstellungspaket für das ZIP-Dateiarchiv für die Funktion und ihre Abhängigkeiten erstellt wird.
# Tutorial: Verwenden eines Amazon-S3-Auslösers zum Erstellen von Miniaturbildern
In diesem Tutorial wird eine Lambda-Funktion erstellt und konfiguriert, die die Größe von Bildern anpasst, die einem Amazon Simple Storage Service (Amazon S3)-Bucket hinzugefügt werden. Wenn Sie Ihrem Bucket eine Bilddatei hinzufügen, ruft Amazon S3 Ihre Lambda-Funktion auf. Die Funktion erstellt daraufhin eine Miniaturversion des Bilds und gibt sie an einen anderen Amazon-S3-Bucket aus.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_resources.png)
Führen Sie für dieses Tutorial die folgenden Schritte aus:
1. Erstellen Sie Quell- und Ziel-Buckets für Amazon S3 und laden Sie ein Beispielbild hoch.
1. Erstellen Sie eine Lambda-Funktion, die die Größe eines Bildes anpasst und eine Miniaturansicht an einen Amazon-S3-Bucket ausgibt.
1. Konfigurieren Sie einen Lambda-Auslöser, der Ihre Funktion aufruft, wenn Objekte in Ihren Quell-Bucket hochgeladen werden.
1. Testen Sie Ihre Funktion zunächst mit einem Dummy-Ereignis und anschließend durch Hochladen eines Bilds in Ihren Quell-Bucket.
Diese Schritte zeigen, wie Sie Lambda verwenden, um eine Dateiverarbeitungsaufgabe für Objekte auszuführen, die einem Amazon-S3-Bucket hinzugefügt werden. Sie können dieses Tutorial mit dem AWS Command Line Interface (AWS CLI) oder dem abschließen AWS-Managementkonsole.
Ein einfacheres Beispiel, das zeigt, wie Sie einen Amazon-S3-Auslöser für Lambda konfigurieren, finden Sie unter [Tutorial: Verwenden eines Amazon-S3-Auslösers zum Aufrufen einer Lambda-Funktion](https://docs.aws.amazon.com/lambda/latest/dg/with-s3-example.html).
**Topics**
+ [Voraussetzungen](#with-s3-example-prereqs)
+ [Erstellen von zwei Amazon-S3-Buckets](#with-s3-tutorial-prepare-create-buckets)
+ [Hochladen eines Testbilds in Ihren Quell-Bucket](#with-s3-tutorial-test-image)
+ [Erstellen einer Berechtigungsrichtlinie](#with-s3-tutorial-create-policy)
+ [Erstellen einer Ausführungsrolle](#with-s3-tutorial-create-execution-role)
+ [Erstellen des Bereitstellungspakets für die Funktion](#with-s3-tutorial-create-function-package)
+ [So erstellen Sie die Lambda-Funktion:](#with-s3-tutorial-create-function-createfunction)
+ [Konfigurieren von Amazon S3 zum Aufrufen der Funktion](#with-s3-tutorial-configure-s3-trigger)
+ [Testen Ihrer Lambda-Funktion mit einem Dummy-Ereignis](#with-s3-tutorial-dummy-test)
+ [Testen Ihrer Funktion mit dem Amazon-S3-Auslöser](#with-s3-tutorial-test-s3)
+ [Bereinigen Ihrer Ressourcen](#s3-tutorial-cleanup)
## Voraussetzungen
Wenn Sie den verwenden möchten, AWS CLI um das Tutorial abzuschließen, installieren Sie die [neueste Version von AWS Command Line Interface]().
Für Ihren Lambda-Funktionscode können Sie Python, Node.js oder Java verwenden. Installieren Sie die Tools zur Sprachunterstützung und einen Paketmanager für die gewünschte Sprache.
### Installieren Sie das AWS Command Line Interface
Wenn Sie das noch nicht installiert haben AWS Command Line Interface, folgen Sie den Schritten unter [Installieren oder Aktualisieren der neuesten Version von AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html), um es zu installieren.
Das Tutorial erfordert zum Ausführen von Befehlen ein Befehlszeilenterminal oder eine Shell. Verwenden Sie unter Linux und macOS Ihre bevorzugte Shell und Ihren bevorzugten Paketmanager.
**Anmerkung**
In Windows werden einige Bash-CLI-Befehle, die Sie häufig mit Lambda verwenden (z. B. `zip`), von den integrierten Terminals des Betriebssystems nicht unterstützt. Um eine in Windows integrierte Version von Ubuntu und Bash zu erhalten, [installieren Sie das Windows-Subsystem für Linux](https://docs.microsoft.com/en-us/windows/wsl/install-win10).
## Erstellen von zwei Amazon-S3-Buckets
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_steps1.png)
Erstellen Sie zunächst zwei Amazon-S3-Buckets. Der erste Bucket ist der Quell-Bucket, in den Sie Ihre Bilder hochladen. Der zweite Bucket wird von Lambda verwendet, um das verkleinerte Miniaturbild zu speichern, wenn Sie Ihre Funktion aufrufen.
------
#### [ AWS-Managementkonsole ]
**So erstellen Sie die Amazon-S3-Buckets (Konsole)**
1. Öffnen Sie die [Amazon-S3-Konsole](https://console.aws.amazon.com/s3) und wählen Sie die Seite **Allzweck-Buckets** aus.
1. Wählen Sie den Ort aus, der Ihrem geografischen Standort AWS-Region am nächsten liegt. Sie können Ihre Region mithilfe der Dropdown-Liste am oberen Bildschirmrand ändern. Später im Tutorial müssen Sie eine Lambda-Funktion in derselben Region erstellen.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/console_region_select.png)
1. Wählen Sie **Create Bucket** (Bucket erstellen) aus.
1. Führen Sie unter **Allgemeine Konfiguration** die folgenden Schritte aus:
1. Stellen Sie sicher, dass für **Bucket-Typ** die Option **Allzweck** ausgewählt ist.
1. Geben Sie für den **Bucket-Namen** einen global eindeutigen Namen ein, der den [Regeln für die Bucket-Benennung](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucketnamingrules.html) von Amazon S3 entspricht. Bucket-Namen dürfen nur aus Kleinbuchstaben, Zahlen, Punkten (.) und Bindestrichen (-) bestehen.
1. Belassen Sie alle anderen Optionen auf ihren Standardwerten und wählen Sie **Bucket erstellen** aus.
1. Wiederholen Sie die Schritte 1 bis 5, 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.
------
#### [ AWS CLI ]
**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](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucketnamingrules.html) 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](https://docs.aws.amazon.com/general/latest/gr/lambda-service.html) 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.
1. 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 aus`LocationConstraint`, 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
```
------
## Hochladen eines Testbilds in Ihren Quell-Bucket
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_steps2.png)
Später im Tutorial testen Sie Ihre Lambda-Funktion, indem Sie sie mit der AWS CLI oder der Lambda-Konsole aufrufen. Damit Sie sich vergewissern können, dass Ihre Funktion ordnungsgemäß funktioniert, muss Ihr Quell-Bucket ein Testbild enthalten. Bei diesem Bild kann es sich um eine beliebige JPG- oder PNG-Datei handeln.
------
#### [ AWS-Managementkonsole ]
**So laden Sie ein Testbild in Ihren Quell-Bucket hoch (Konsole)**
1. Öffnen Sie die Seite [Buckets](https://console.aws.amazon.com/s3/buckets) der Amazon-S3-Konsole.
1. Wählen Sie den Quell-Bucket aus, den Sie im vorherigen Schritt erstellt haben.
1. Klicken Sie auf **Hochladen**.
1. Wählen Sie **Dateien hinzufügen** aus und wählen Sie mit der Dateiauswahl das Objekt aus, das Sie hochladen möchten.
1. Wählen Sie **Öffnen** und anschließend **Hochladen** aus.
------
#### [ AWS CLI ]
**So laden Sie ein Testbild in Ihren Quell-Bucket hoch (AWS CLI)**
+ Führen Sie in dem Verzeichnis, das das hochzuladende Bild enthält, 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
```
------
## Erstellen einer Berechtigungsrichtlinie
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_steps3.png)
Im ersten Schritt der Erstellung Ihrer Lambda-Funktion wird eine Berechtigungsrichtlinie erstellt. Diese Richtlinie gibt Ihrer Funktion die Berechtigungen, die sie für den Zugriff auf andere Ressourcen benötigt. AWS In diesem Tutorial gewährt die Richtlinie Lambda Lese- und Schreibberechtigungen für Amazon S3 S3-Buckets und ermöglicht es ihm, in Amazon CloudWatch Logs zu schreiben.
------
#### [ AWS-Managementkonsole ]
**So erstellen Sie die Richtlinie (Konsole)**
1. Öffnen Sie die Seite [Richtlinien](https://console.aws.amazon.com/iamv2/home#policies) der AWS Identity and Access Management (IAM-) Konsole.
1. Wählen Sie **Richtlinie erstellen** aus.
1. Wählen Sie die Registerkarte **JSON** aus und kopieren Sie dann die folgende benutzerdefinierte JSON-Richtlinie in den JSON-Editor.
****
```
{
"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. Wählen Sie **Weiter** aus.
1. Geben Sie unter **Richtliniendetails** für den **Richtliniennamen** `LambdaS3Policy` ein.
1. Wählen Sie **Richtlinie erstellen** aus.
------
#### [ AWS CLI ]
**So erstellen Sie die Richtlinie (AWS CLI)**
1. Speichern Sie den folgenden JSON-Code in einer Datei mit dem Namen `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. 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
```
------
## Erstellen einer Ausführungsrolle
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_steps4.png)
Eine Ausführungsrolle ist eine IAM-Rolle, die einer Lambda-Funktion Zugriff AWS-Services und Ressourcen gewährt. Um Ihrer Funktion Lese- und Schreibzugriff auf einen Amazon-S3-Bucket zu erteilen, fügen Sie die Berechtigungsrichtlinie an, die Sie im vorherigen Schritt erstellt haben.
------
#### [ AWS-Managementkonsole ]
**So erstellen Sie eine Ausführungsrolle und fügen Ihre Berechtigungsrichtlinie hinzu (Konsole)**
1. Öffnen Sie die Seite [Rollen](https://console.aws.amazon.com/iamv2/home#roles) der (IAM-)Konsole.
1. Wählen Sie **Rolle erstellen** aus.
1. Wählen Sie unter **Vertrauenswürdiger Entitätstyp** die Option **AWS-Service** und unter **Anwendungsfall** die Option **Lambda** aus.
1. Wählen Sie **Weiter** aus.
1. Fügen Sie die Berechtigungsrichtlinie hinzu, die Sie im vorherigen Schritt erstellt haben:
1. Geben Sie im Feld für die Richtliniensuche `LambdaS3Policy` ein.
1. Aktivieren Sie in den Suchergebnissen das Kontrollkästchen für `LambdaS3Policy`.
1. Wählen Sie **Weiter** aus.
1. Geben Sie unter **Rollendetails** im Feld **Rollenname** den Namen `LambdaS3Role` ein.
1. Wählen Sie **Rolle erstellen** aus.
------
#### [ AWS CLI ]
**So erstellen Sie eine Ausführungsrolle und fügen Ihre Berechtigungsrichtlinie an (AWS CLI)**
1. Speichern Sie den folgenden JSON-Code in einer Datei mit dem Namen `trust-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"
}
]
}
```
1. Führen Sie in dem Verzeichnis, in dem Sie das JSON-Vertrauensrichtliniendokument 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
```
1. Führen Sie den folgenden CLI-Befehl aus, um die im vorherigen Schritt erstellte Berechtigungsrolle anzufügen. Ersetzen Sie die AWS-Konto Nummer im ARN der Police durch Ihre eigene Kontonummer.
```
aws iam attach-role-policy --role-name LambdaS3Role --policy-arn arn:aws:iam::123456789012:policy/LambdaS3Policy
```
------
## Erstellen des Bereitstellungspakets für die Funktion
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_steps5.png)
Um Ihre Funktion zu erstellen, erstellen Sie ein *Bereitstellungspaket*, das Ihren Funktionscode und die zugehörigen Abhängigkeiten enthält. Bei der hier verwendeten Funktion `CreateThumbnail` verwendet Ihr Funktionscode eine separate Bibliothek für die Anpassung der Bildgröße. Folgen Sie den Anweisungen für die von Ihnen gewählte Sprache, um ein Bereitstellungspaket zu erstellen, das die erforderliche Bibliothek enthält.
------
#### [ Node.js ]
**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
```
1. Erstellen Sie ein neues Node.js-Projekt mit `npm`. Um die im interaktiven Erlebnis bereitgestellten Standardoptionen zu akzeptieren, drücken Sie `Enter`.
```
npm init
```
1. Speichern Sie den folgenden Funktionscode in einer lokalen Datei namens `index.mjs`: Stellen Sie sicher, dass Sie `us-east-1` durch das AWS-Region ersetzen, in dem 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);
};
```
1. 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
```
1. 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.
------
#### [ Python ]
**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))
```
1. Erstellen Sie in dem Verzeichnis, in dem Sie auch Ihre `lambda_function.py`-Datei erstellt haben, ein neues Verzeichnis mit dem Namen `package` und installieren Sie die Bibliothek [Pillow (PIL)](https://pypi.org/project/Pillow/) sowie das AWS SDK für Python (Boto3). Die Lambda-Python-Laufzeit enthält zwar eine Version des Boto3 SDK, es empfiehlt sich jedoch, dem Bereitstellungspaket alle Abhängigkeiten Ihrer Funktion hinzuzufügen, auch wenn sie in der Laufzeit enthalten sind. Weitere Informationen finden Sie in der [Laufzeitabhängigkeiten in 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
```
Die Pillow-Bibliothek enthält Code in C/C\$1\$1. 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.
1. 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.
Sie können Ihr Bereitstellungspaket auch in einer virtuellen Python-Umgebung erstellen. Siehe [Arbeiten mit ZIP-Dateiarchiven und Python-Lambda-Funktionen](python-package.md)
------
## So erstellen Sie die Lambda-Funktion:
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_steps6.png)
Sie können Ihre Lambda-Funktion entweder mit der AWS CLI oder der Lambda-Konsole erstellen. Folgen Sie den Anweisungen für die von Ihnen gewählte Sprache, um die Funktion zu erstellen.
------
#### [ AWS-Managementkonsole ]
**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 die im vorherigen Schritt erstellte ZIP- oder JAR-Datei hochladen.
1. Öffnen Sie die Seite [Funktionen](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole.
1. 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.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/console_region_select.png)
1. Wählen Sie **Funktion erstellen**.
1. Wählen Sie **Author from scratch** aus.
1. Führen Sie unter **Basic information** (Grundlegende Informationen) die folgenden Schritte aus:
1. Geben Sie für **Function name** (Funktionsname) `CreateThumbnail` ein.
1. Wählen Sie für **Laufzeit** entweder **Node.js 22.x** oder **Python 3.12**, je nachdem, welche Sprache Sie für Ihre Funktion gewählt haben.
1. Wählen Sie für **Architektur** **x86\$164** aus.
1. 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.
1. Wählen Sie die zuvor erstellte `LambdaS3Role` aus.
1. Wählen Sie **Funktion erstellen**.
**So laden Sie den Funktionscode hoch (Konsole)**
1. Wählen Sie im Bereich **Codequelle** die Option **Hochladen von** aus.
1. Wählen Sie die **ZIP-Datei** aus.
1. Klicken Sie auf **Upload**.
1. Wählen Sie in der Dateiauswahl Ihre ZIP-Datei und anschließend **Öffnen** aus.
1. Wählen Sie **Speichern**.
------
#### [ AWS CLI ]
**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 nodejs24.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.14 --timeout 10 --memory-size 1024 \
--role arn:aws:iam::123456789012:role/LambdaS3Role --region us-east-1
```
------
## Konfigurieren von Amazon S3 zum Aufrufen der Funktion
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_steps7.png)
Damit Ihre Lambda-Funktion ausgeführt wird, wenn Sie ein Bild in Ihren Quell-Bucket hochladen, müssen Sie einen Auslöser für Ihre Funktion konfigurieren. Sie können den Amazon-S3-Auslöser entweder über die Konsole oder mithilfe der AWS CLI konfigurieren.
**Wichtig**
Mit diesem Verfahren wird der Amazon-S3-Bucket so konfiguriert, dass die Funktion jedes Mal aufgerufen wird, wenn ein Objekt im Bucket erstellt wird. Konfigurieren Sie dieses Verhalten nur für den Quell-Bucket. Wenn Ihre Lambda-Funktion Objekte in dem Bucket erstellt, der sie aufruft, kann es passieren, dass Ihre Funktion [kontinuierlich in einer Schleife aufgerufen](https://serverlessland.com/content/service/lambda/guides/aws-lambda-operator-guide/recursive-runaway) wird. Dies kann dazu führen, dass Ihnen AWS-Konto unerwartete Gebühren in Rechnung gestellt werden.
------
#### [ AWS-Managementkonsole ]
**So konfigurieren Sie den Amazon-S3-Auslöser (Konsole)**
1. Öffnen Sie die Seite [Funktionen](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole und wählen Sie Ihre Funktion (`CreateThumbnail`) aus.
1. Wählen Sie **Add trigger**.
1. Wählen Sie **S3** aus.
1. Wählen Sie unter **Bucket** Ihren Quell-Bucket aus.
1. Wählen Sie unter **Ereignistypen** die Option **Alle Objekterstellungsereignisse** aus.
1. 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](https://serverlessland.com/content/service/lambda/guides/aws-lambda-operator-guide/recursive-runaway).
1. Wählen Sie **Hinzufügen** aus.
Wenn Sie einen Auslöser über die Lambda-Konsole erstellen, erstellt Lambda automatisch eine [ressourcenbasierte Richtlinie](https://docs.aws.amazon.com/lambda/latest/dg/access-control-resource-based.html), um dem von Ihnen ausgewählten Dienst die Berechtigung zum Aufrufen Ihrer Funktion zu erteilen.
------
#### [ AWS CLI ]
**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](https://docs.aws.amazon.com/lambda/latest/dg/access-control-resource-based.html) 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 Berechtigung zum Aufrufen Ihrer Funktion zu erteilen. 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.
1. Speichern Sie den folgenden JSON-Code in einer Datei mit dem Namen `notification.json`: Wenn dieser JSON-Code auf Ihren Quell-Bucket angewendet wird, wird der Bucket so konfiguriert, 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" ]
}
]
}
```
1. 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-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/put-bucket-notification-configuration.html)in der *AWS CLI-Befehlsreferenz*.
------
## Testen Ihrer Lambda-Funktion mit einem Dummy-Ereignis
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_steps8.png)
Bevor Sie Ihr gesamtes Setup testen, indem Sie Ihrem Amazon-S3-Quell-Bucket eine Bilddatei hinzufügen, testen Sie, ob Ihre Lambda-Funktion ordnungsgemäß funktioniert, indem Sie sie mit einem Dummy-Ereignis aufrufen. In Lambda ist ein Ereignis ein Dokument im JSON-Format, das Daten enthält, die von Ihrer Lambda-Funktion verarbeitet werden sollen. Wenn Ihre Funktion von Amazon S3 aufgerufen wird, enthält das an Ihre Funktion gesendete Ereignis Informationen wie den Bucket-Namen, den Bucket-ARN und den Objektschlüssel.
------
#### [ AWS-Managementkonsole ]
**So testen Sie Ihre Lambda-Funktion mit einem Dummy-Ereignis (Konsole)**
1. Öffnen Sie die Seite [Funktionen](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole und wählen Sie Ihre Funktion (`CreateThumbnail`) aus.
1. Wählen Sie die Registerkarte **Test**.
1. 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.
1. Geben Sie für **Event name (Ereignisname)** **myTestEvent** ein.
1. Wählen Sie unter **Vorlage** die Option **S3 Put** aus.
1. Ersetzen Sie die Werte für die folgenden Parameter durch Ihre eigenen Werte:
+ Ersetzen Sie für durch den`awsRegion`, 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](#with-s3-tutorial-test-image) 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"
}
}
}
]
}
```
1. Wählen Sie **Speichern**.
1. Wählen Sie im Bereich **Testereignis** die Option **Testen** aus.
1. 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](https://console.aws.amazon.com/s3/buckets) der Amazon-S3-Konsole.
1. Wählen Sie Ihren Ziel-Bucket aus und vergewissern Sie sich, dass die Datei, deren Größe angepasst wurde, im Bereich **Objekte** vorhanden ist.
------
#### [ AWS CLI ]
**So testen Sie Ihre Lambda-Funktion mit einem Dummy-Ereignis (AWS CLI)**
1. Speichern Sie den folgenden JSON-Code in einer Datei mit dem Namen `dummyS3Event.json`: Ersetzen Sie die Werte für die folgenden Parameter durch Ihre eigenen Werte:
+ Ersetzen Sie für durch den`awsRegion`, 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](#with-s3-tutorial-test-image) 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"
}
}
}
]
}
```
1. Rufen Sie die Funktion in dem Verzeichnis auf, in dem Sie die Datei `dummyS3Event.json` 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](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
```
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](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list).
1. 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 ersetzen Sie dabei `amzn-s3-demo-source-bucket-resized` 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"
}
]
}
```
------
## Testen Ihrer Funktion mit dem Amazon-S3-Auslöser
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_steps9.png)
Nachdem Sie sich vergewissert haben, dass Ihre Lambda-Funktion ordnungsgemäß funktioniert, können Sie Ihr gesamtes Setup testen, indem Sie Ihrem Amazon-S3-Quell-Bucket eine Bilddatei hinzufügen. Wenn Sie Ihr Bild dem Quell-Bucket hinzufügen, sollte Ihre Lambda-Funktion automatisch aufgerufen werden. Ihre Funktion erstellt eine verkleinerte Version der Datei und speichert sie in Ihrem Ziel-Bucket.
------
#### [ AWS-Managementkonsole ]
**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](https://console.aws.amazon.com/s3/buckets) der Amazon-S3-Konsole und wählen Sie Ihren Quell-Bucket aus.
1. Klicken Sie auf **Upload**.
1. 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.
1. Wählen Sie **Öffnen** und anschließend **Hochladen** aus.
1. Vergewissern Sie sich, dass Lambda eine verkleinerte Version Ihrer Bilddatei in Ihrem Ziel-Bucket gespeichert hat:
1. Navigieren Sie wieder zur Seite [Buckets](https://console.aws.amazon.com/s3/buckets) der Amazon-S3-Konsole und wählen Sie Ihren Ziel-Bucket aus.
1. 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.
------
#### [ AWS CLI ]
**So testen Sie Ihre Lambda-Funktion unter Verwendung des Amazon-S3-Auslösers (AWS CLI)**
1. Führen Sie in dem Verzeichnis, das das hochzuladende Bild enthält, 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
```
1. 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 ersetzen Sie dabei `amzn-s3-demo-source-bucket-resized` 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"
}
]
}
```
------
## Bereinigen Ihrer Ressourcen
Sie können jetzt die Ressourcen, die Sie für dieses Tutorial erstellt haben, löschen, es sei denn, Sie möchten sie behalten. Durch das Löschen von AWS Ressourcen, die Sie nicht mehr verwenden, vermeiden Sie unnötige Kosten für Ihre AWS-Konto.
**So löschen Sie die Lambda-Funktion:**
1. Öffnen Sie die Seite [Funktionen](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole.
1. Wählen Sie die Funktion aus, die Sie erstellt haben.
1. Wählen Sie **Aktionen**, **Löschen** aus.
1. Geben Sie **confirm** in das Texteingabefeld ein und wählen Sie **Delete** (Löschen) aus.
**So löschen Sie die von Ihnen erstellte Richtlinie**
1. Öffnen Sie die Seite [Richtlinien](https://console.aws.amazon.com/iam/home#/policies) in der IAM-Konsole.
1. Wählen Sie die Richtlinie aus, die Sie erstellt haben (**AWSLambdaS3Policy**).
1. Wählen Sie **Policy actions (Richtlinienaktionen)** und anschließend **Delete (Löschen)** aus.
1. Wählen Sie **Löschen** aus.
**So löschen Sie die Ausführungsrolle**
1. Öffnen Sie die Seite [Roles](https://console.aws.amazon.com/iam/home#/roles) in der IAM-Konsole.
1. Wählen Sie die von Ihnen erstellte Ausführungsrolle aus.
1. Wählen Sie **Löschen** aus.
1. Geben Sie den Namen der Rolle in das Texteingabefeld ein und wählen Sie **Delete** (Löschen) aus.
**So löschen Sie den S3-Bucket:**
1. Öffnen Sie die [Amazon S3-Konsole](https://console.aws.amazon.com//s3/home#).
1. Wählen Sie den Bucket aus, den Sie erstellt haben.
1. Wählen Sie **Löschen** aus.
1. Geben Sie den Namen des Buckets in das Texteingabefeld ein.
1. Wählen Sie **Bucket löschen** aus.