Voraussetzungen Erstellen eines Amazon-S3-Buckets Hochladen eines Testobjekts in Ihren Bucket Erstellen einer Berechtigungsrichtlinie Erstellen einer Ausführungsrolle So erstellen Sie die Lambda-Funktion:Bereitstellen des Funktionscodes Erstellen des Amazon-S3-Auslösers Lambda-Funktion testen Bereinigen Ihrer Ressourcen Nächste Schritte

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 in Amazon CloudWatch Logs ausgegeben.

Diagramm, das den Datenfluss zwischen einem Amazon S3 S3-Bucket, einer Lambda-Funktion und Amazon CloudWatch Logs zeigt

Dieses Tutorial zeigt, wie Sie:

Erstellen Sie einen Amazon-S3-Bucket.
Erstellen Sie eine Lambda-Funktion, die den Objekttyp von Objekten in einem Amazon-S3-Bucket ausgibt.
Konfigurieren Sie einen Lambda-Auslöser, der Ihre Funktion aufruft, wenn Objekte in Ihren Bucket hochgeladen werden.
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 Management Console verwenden.

Voraussetzungen

Wenn Sie noch keine haben AWS-Konto, führen Sie die folgenden Schritte aus, um eine zu erstellen.

Um sich für eine anzumelden AWS-Konto

Öffnen Sie https://portal.aws.amazon.com/billing/signup.
Folgen Sie den Online-Anweisungen.

Bei der Anmeldung müssen Sie auch einen Telefonanruf entgegennehmen und einen Verifizierungscode über die Telefontasten eingeben.

Wenn Sie sich für eine anmelden AWS-Konto, Root-Benutzer des AWS-Kontoswird eine erstellt. Der Root-Benutzer hat Zugriff auf alle AWS-Services und Ressourcen des Kontos. Als bewährte Sicherheitsmethode weisen Sie einem Administratorbenutzer Administratorzugriff zu und verwenden Sie nur den Root-Benutzer, um Aufgaben auszuführen, die Root-Benutzerzugriff erfordern.

AWS sendet Ihnen nach Abschluss des Anmeldevorgangs eine Bestätigungs-E-Mail. Sie können jederzeit Ihre aktuelle Kontoaktivität anzeigen und Ihr Konto verwalten. Rufen Sie dazu https://aws.amazon.com/ auf und klicken Sie auf Mein Konto.

Nachdem Sie sich für einen angemeldet haben AWS-Konto, sichern Sie Ihren Root-Benutzer des AWS-Kontos AWS IAM Identity Center, aktivieren und erstellen Sie einen Administratorbenutzer, sodass Sie den Root-Benutzer nicht für alltägliche Aufgaben verwenden.

Sichern Sie Ihre Root-Benutzer des AWS-Kontos

Melden Sie sich AWS Management Consoleals Kontoinhaber an, indem Sie Root-Benutzer auswählen und Ihre AWS-Konto E-Mail-Adresse eingeben. Geben Sie auf der nächsten Seite Ihr Passwort ein.

Hilfe bei der Anmeldung mit dem Root-Benutzer finden Sie unter Anmelden als Root-Benutzer im AWS-Anmeldung Benutzerhandbuch zu.
Aktivieren Sie die Multi-Faktor-Authentifizierung (MFA) für den Root-Benutzer.

Anweisungen finden Sie unter Aktivieren eines virtuellen MFA-Geräts für Ihren AWS-Konto Root-Benutzer (Konsole) im IAM-Benutzerhandbuch.

Erstellen eines Administratorbenutzers

Aktivieren Sie das IAM Identity Center.

Anweisungen finden Sie unter Aktivieren AWS IAM Identity Center im AWS IAM Identity Center Benutzerhandbuch.
Gewähren Sie einem Administratorbenutzer im IAM Identity Center Administratorzugriff.

Ein Tutorial zur Verwendung von IAM-Identity-Center-Verzeichnis als Identitätsquelle finden Sie IAM-Identity-Center-Verzeichnis im Benutzerhandbuch unter Benutzerzugriff mit der Standardeinstellung konfigurieren.AWS IAM Identity Center

Anmelden als Administratorbenutzer

Um sich mit Ihrem IAM-Identity-Center-Benutzer anzumelden, verwenden Sie die Anmelde-URL, die an Ihre E-Mail-Adresse gesendet wurde, als Sie den IAM-Identity-Center-Benutzer erstellt haben.

Hilfe bei der Anmeldung mit einem IAM Identity Center-Benutzer finden Sie im AWS-Anmeldung Benutzerhandbuch unter Anmeldung beim AWS Access-Portal.

Erstellen eines Amazon-S3-Buckets

Das Workflow-Diagramm des Tutorials zeigt, dass Sie sich im Amazon-S3-Bucket-Schritt zum Erstellen des Buckets befinden.

So erstellen Sie einen Amazon-S3-Bucket

Öffnen Sie die Amazon-S3-Konsole und wählen Sie die Seite Buckets aus.
Wählen Sie Bucket erstellen aus.
Führen Sie unter Allgemeine Konfiguration die folgenden Schritte aus:
1. Geben Sie für den Bucket-Namen einen global eindeutigen Namen ein, der den Regeln für die Bucket-Benennung von Amazon S3 entspricht. Bucket-Namen dürfen nur aus Kleinbuchstaben, Zahlen, Punkten (.) und Bindestrichen (-) bestehen.
2. Wählen Sie unter AWS -Region eine Region aus. Später im Tutorial müssen Sie eine Lambda-Funktion in derselben Region erstellen.
Belassen Sie alle anderen Optionen auf ihren Standardwerten und wählen Sie Bucket erstellen aus.

Hochladen eines Testobjekts in Ihren Bucket

Hochladen eines Testobjekts

Öffnen Sie die Buckets-Seite der Amazon-S3-Konsole und wählen Sie den Bucket aus, den Sie im vorherigen Schritt erstellt haben.
Klicken Sie auf Hochladen.
Wählen Sie Dateien hinzufügen und wählen Sie das Objekt aus, das Sie hochladen möchten. Sie können eine beliebige Datei auswählen (z. B.HappyFace.jpg).
Wählen Sie Öffnen und anschließend Hochladen aus.

Später im Tutorial testen Sie Ihre Lambda-Funktion mit diesem Objekt.

Erstellen einer Berechtigungsrichtlinie

Das Workflow-Diagramm des Tutorials zeigt, dass Sie sich im Lambda-Funktionsschritt zum Erstellen der Berechtigungsrichtlinie befinden.

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

Öffnen Sie die Seite Richtlinien in der IAM-Konsole.
Wählen Sie Richtlinie erstellen aus.

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:::*/*"
        }
    ]
}

Wählen Sie Next: Tags (Weiter: Tags) aus.
Klicken Sie auf Weiter: Prüfen.
Geben Sie unter Review policy (Richtlinie prüfen) für den Richtlinien-Namen s3-trigger-tutorial ein.
Wählen Sie Richtlinie erstellen aus.

Erstellen einer Ausführungsrolle

Das Workflow-Diagramm des Tutorials zeigt, dass Sie sich im Lambda-Funktionsschritt zum Erstellen der Ausführungsrolle befinden.

Eine Ausführungsrolle ist eine AWS Identity and Access Management (IAM-) Rolle, die einer Lambda-Funktion die Berechtigung zum Zugriff auf AWS Dienste und Ressourcen gewährt. Erstellen Sie in diesem Schritt eine Ausführungsrolle mithilfe der Berechtigungsrichtlinie, die Sie im vorherigen Schritt erstellt haben.

So erstellen Sie eine Ausführungsrolle und fügen Ihre benutzerdefinierte Berechtigungsrichtlinie hinzu

Öffnen Sie die Seite Roles (Rollen) in der IAM-Konsole.
Wählen Sie Rolle erstellen aus.
Wählen Sie als Typ der vertrauenswürdigen Entität AWS -Service und dann als Anwendungsfall Lambda aus.
Wählen Sie Weiter aus.
Geben Sie im Feld für die Richtliniensuche s3-trigger-tutorial ein.
Wählen Sie in den Suchergebnissen die von Ihnen erstellte Richtlinie (s3-trigger-tutorial) und dann die Option Next (Weiter) aus.
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:

Das Workflow-Diagramm des Tutorials zeigt, dass Sie sich im Lambda-Funktionsschritt zum Erstellen der Funktion befinden.

Erstellen Sie mit der Python 3.12-Laufzeit eine Lambda-Funktion in der Konsole.

So erstellen Sie die Lambda-Funktion:

Öffnen Sie die Seite Funktionen der Lambda-Konsole.
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.
Wählen Sie Funktion erstellen.
Wählen Sie Ohne Vorgabe erstellen aus.
Führen Sie unter Basic information (Grundlegende Informationen) die folgenden Schritte aus:
1. Geben Sie unter Funktionsname s3-trigger-tutorial ein.
2. Wählen Sie für Runtime Python 3.12.
3. Wählen Sie für Architektur x86_64 aus.
Gehen Sie auf der Registerkarte Standard-Ausführungsrolle ändern wie folgt vor:
1. Erweitern Sie die Registerkarte und wählen Sie dann Verwenden einer vorhandenen Rolle aus.
2. Wählen Sie die zuvor erstellte lambda-s3-trigger-role aus.
Wählen Sie Funktion erstellen.

Bereitstellen des Funktionscodes

Das Workflow-Diagramm des Tutorials zeigt, dass Sie sich im Lambda-Funktionsschritt zum Bereitstellen des Codes befinden.

Dieses Tutorial verwendet die Python 3.12-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_object von, AWS SDK for Python (Boto3) um die Metadaten des Objekts abzurufen, einschließlich des Inhaltstyps (MIME-Typ) des hochgeladenen Objekts.

So stellen Sie den Funktionscode bereit

Wählen Sie im folgenden Feld die Registerkarte Python und kopieren Sie den Code.

.NET

AWS SDK for .NET

Anmerkung

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.

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

Anmerkung

Es gibt noch mehr GitHub. Das vollständige Beispiel sowie eine Anleitung zum Einrichten und Ausführen finden Sie im Repository mit Serverless-Beispielen.

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

Anmerkung

Es gibt noch mehr GitHub. Das vollständige Beispiel sowie eine Anleitung zum Einrichten und Ausführen finden Sie im Repository mit Serverless-Beispielen.

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)

Anmerkung

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.

Konsumieren eines S3-Ereignisses mit Lambda unter Verwendung JavaScript.


// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
import { S3Client, HeadObjectCommand } from "@aws-sdk/client-s3";

const client = new S3Client();

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

Anmerkung

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.

Ein S3-Ereignis mit Lambda mithilfe von PHP konsumieren.


// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
<?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)

Anmerkung

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.

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

Anmerkung

Es gibt noch mehr GitHub. Das vollständige Beispiel sowie eine Anleitung zum Einrichten und Ausführen finden Sie im Repository mit Serverless-Beispielen.

Ein S3-Ereignis mit Lambda mithilfe von Ruby konsumieren.


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

Anmerkung

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.

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(())
}

Fügen Sie den Code im Bereich Codequelle der Lambda-Konsole in die Datei lambda_function.py ein.
Wählen Sie Bereitstellen.

Erstellen des Amazon-S3-Auslösers

Das Workflow-Diagramm des Tutorials zeigt, dass Sie sich im S3-Auslöser-Schritt zum Erstellen des Auslösers befinden.

Erstellen des Amazon-S3-Auslösers

Wählen Sie im Bereich Function overview (Funktionsübersicht) die Option Add trigger (Auslöser hinzufügen).
Wählen Sie S3 aus.
Wählen Sie unter Bucket den Bucket aus, den Sie zuvor im Tutorial erstellt haben.
Vergewissern Sie sich, dass unter Ereignistypen die Option Alle Ereignisse zur Objekterstellung ausgewählt ist.
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.
Wählen Sie Hinzufügen aus.

Testen Ihrer Lambda-Funktion mit einem Dummy-Ereignis

Das Workflow-Diagramm des Tutorials zeigt, dass Sie sich im Testschritt zum Testen mit einem Dummy-Ereignis befinden.

So testen Sie die Lambda-Funktion mit einem Dummy-Ereignis

Wählen Sie auf der Lambda-Konsolenseite für Ihre Funktion die Registerkarte Test aus.
Geben Sie für Event name (Ereignisname) MyTestEvent ein.

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 my-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": "my-bucket",
          "ownerIdentity": {
            "principalId": "EXAMPLE"
          },
          "arn": "arn:aws:s3:::my-bucket"
        },
        "object": {
          "key": "test%2Fkey",
          "size": 1024,
          "eTag": "0123456789abcdef0123456789abcdef",
          "sequencer": "0A1B2C3D4E5F678901"
        }
      }
    }
  ]
}

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

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: 'my-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

Das Workflow-Diagramm des Tutorials zeigt, dass Sie sich im Testschritt zum Verwenden des S3-Auslösers befinden.

Um Ihre Funktion mit dem konfigurierten Trigger zu testen, laden Sie über die Konsole ein Objekt in Ihren Amazon S3 S3-Bucket hoch. 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

Öffnen Sie die Buckets-Seite der Amazon S3 S3-Konsole und wählen Sie den Bucket aus, den Sie zuvor erstellt haben.
Klicken Sie auf Hochladen.
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.
Wählen Sie Öffnen und anschließend Hochladen aus.

Um den Funktionsaufruf mithilfe von Logs zu überprüfen CloudWatch

Öffnen Sie die CloudWatch-Konsole.
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.
Wählen Sie Protokolle und anschließend Protokollgruppen aus.
Wählen Sie die Protokollgruppe für Ihre Funktion (/aws/lambda/s3-trigger-tutorial) aus.
Wählen Sie im Bereich Protokollstreams den neuesten Protokollstream aus.
Wenn Ihre Funktion als Reaktion auf Ihren Amazon S3 S3-Trigger 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, verhindern Sie unnötige Gebühren für Ihre AWS-Konto.

So löschen Sie die Lambda-Funktion:

Öffnen Sie die Seite Funktionen der Lambda-Konsole.
Wählen Sie die Funktion aus, die Sie erstellt haben.
Wählen Sie Aktionen, Löschen aus.
Geben Sie delete in das Texteingabefeld ein und wählen Sie Delete (Löschen) aus.

So löschen Sie die Ausführungsrolle

Öffnen Sie die Seite Roles in der IAM-Konsole.
Wählen Sie die von Ihnen erstellte Ausführungsrolle aus.
Wählen Sie Löschen aus.
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:

Öffnen Sie die Amazon S3-Konsole.
Wählen Sie den Bucket aus, den Sie erstellt haben.
Wählen Sie Löschen aus.
Geben Sie den Namen des Buckets in das Texteingabefeld ein.
Wählen Sie Bucket löschen aus.

Nächste Schritte

In Tutorial: Verwenden eines Amazon-S3-Auslösers zum Erstellen von Miniaturbildern ruft der Amazon S3 S3-Trigger 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.

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

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