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.

# Tutorial: Verwenden eines Amazon-S3-Auslösers zum Aufrufen einer Lambda-Funktion
<a name="with-s3-example"></a>

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

![\[\]](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
<a name="with-s3-example-upload-test-object"></a>

![\[\]](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
<a name="with-s3-example-create-policy"></a>

![\[\]](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
<a name="with-s3-example-create-role"></a>

![\[\]](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:
<a name="with-s3-example-create-function"></a>

![\[\]](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
<a name="with-s3-example-deploy-code"></a>

![\[\]](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<string> Handler(S3Event evt, ILambdaContext context)
           {
               try
               {
                   if (evt.Records.Count <= 0)
                   {
                       context.Logger.LogLine("Empty S3 Event received");
                       return string.Empty;
                   }
   
                   var bucket = evt.Records[0].S3.Bucket.Name;
                   var key = HttpUtility.UrlDecode(evt.Records[0].S3.Object.Key);
   
                   context.Logger.LogLine($"Request is for {bucket} and {key}");
   
                   var objectResult = await _s3Client.GetObjectAsync(bucket, key);
   
                   context.Logger.LogLine($"Returning {objectResult.Key}");
   
                   return objectResult.Key;
               }
               catch (Exception e)
               {
                   context.Logger.LogLine($"Error processing request - {e.Message}");
   
                   return string.Empty;
               }
           }
       }
   }
   ```

------
#### [ Go ]

**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<S3Event, String> {
       private static final Logger logger = LoggerFactory.getLogger(Handler.class);
       @Override
       public String handleRequest(S3Event s3event, Context context) {
           try {
             S3EventNotificationRecord record = s3event.getRecords().get(0);
             String srcBucket = record.getS3().getBucket().getName();
             String srcKey = record.getS3().getObject().getUrlDecodedKey();
   
             S3Client s3Client = S3Client.builder().build();
             HeadObjectResponse headObject = getHeadObject(s3Client, srcBucket, srcKey);
   
             logger.info("Successfully retrieved " + srcBucket + "/" + srcKey + " of type " + headObject.contentType());
   
             return "Ok";
           } catch (Exception e) {
             throw new RuntimeException(e);
           }
       }
   
       private HeadObjectResponse getHeadObject(S3Client s3Client, String bucket, String key) {
           HeadObjectRequest headObjectRequest = HeadObjectRequest.builder()
                   .bucket(bucket)
                   .key(key)
                   .build();
           return s3Client.headObject(headObjectRequest);
       }
   }
   ```

------
#### [ JavaScript ]

**SDK 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<string | undefined> => {
     // Get the object from the event and show its content type
     const bucket = event.Records[0].s3.bucket.name;
     const key = decodeURIComponent(event.Records[0].s3.object.key.replace(/\+/g, ' '));
     const params = {
       Bucket: bucket,
       Key: key,
     };
     try {
       const { ContentType } = await s3.send(new HeadObjectCommand(params));
       console.log('CONTENT TYPE:', ContentType);
       return ContentType;
     } catch (err) {
       console.log(err);
       const message = `Error getting object ${key} from bucket ${bucket}. Make sure they exist and your bucket is in the same region as this function.`;
       console.log(message);
       throw new Error(message);
     }
   };
   ```

------
#### [ PHP ]

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

   ```
   <?php
   
   use Bref\Context\Context;
   use Bref\Event\S3\S3Event;
   use Bref\Event\S3\S3Handler;
   use Bref\Logger\StderrLogger;
   
   require __DIR__ . '/vendor/autoload.php';
   
   
   class Handler extends S3Handler 
   {
       private StderrLogger $logger;
       public function __construct(StderrLogger $logger)
       {
           $this->logger = $logger;
       }
       
       public function handleS3(S3Event $event, Context $context) : void
       {
           $this->logger->info("Processing S3 records");
   
           // Get the object from the event and show its content type
           $records = $event->getRecords();
           
           foreach ($records as $record) 
           {
               $bucket = $record->getBucket()->getName();
               $key = urldecode($record->getObject()->getKey());
   
               try {
                   $fileSize = urldecode($record->getObject()->getSize());
                   echo "File Size: " . $fileSize . "\n";
                   // TODO: Implement your custom processing logic here
               } catch (Exception $e) {
                   echo $e->getMessage() . "\n";
                   echo 'Error getting object ' . $key . ' from bucket ' . $bucket . '. Make sure they exist and your bucket is in the same region as this function.' . "\n";
                   throw $e;
               }
           }
       }
   }
   
   $logger = new StderrLogger();
   return new Handler($logger);
   ```

------
#### [ Python ]

**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<S3Event>| {
           function_handler(&s3_client, request)
       })).await;
   
       res
   }
   
   async fn function_handler(
       s3_client: &Client,
       evt: LambdaEvent<S3Event>
   ) -> Result<(), Error> {
       tracing::info!(records = ?evt.payload.records.len(), "Received request from SQS");
   
       if evt.payload.records.len() == 0 {
           tracing::info!("Empty S3 event received");
       }
   
       let bucket = evt.payload.records[0].s3.bucket.name.as_ref().expect("Bucket name to exist");
       let key = evt.payload.records[0].s3.object.key.as_ref().expect("Object key to exist");
   
       tracing::info!("Request is for {} and object {}", bucket, key);
   
       let s3_get_object_result = s3_client
           .get_object()
           .bucket(bucket)
           .key(key)
           .send()
           .await;
   
       match s3_get_object_result {
           Ok(_) => tracing::info!("S3 Get Object success, the s3GetObjectResult contains a 'body' property of type ByteStream"),
           Err(_) => tracing::info!("Failure with S3 Get Object request")
       }
   
       Ok(())
   }
   ```

------

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

![\[\]](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
<a name="with-s3-example-test-dummy-event"></a>

![\[\]](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
<a name="with-s3-example-test-s3-trigger"></a>

![\[\]](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
<a name="cleanup"></a>

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
<a name="next-steps"></a>

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.