Walkthrough-Übersicht Schritt 1: Erstellen einer Amazon SQS-Warteschlange Schritt 2: Erstellen eines Amazon SNS-Themas Schritt 3: Hinzufügen einer Benachrichtigungskonfiguration zu Ihrem Bucket Schritt 4: Testen der Einrichtung

Walkthrough: Konfigurieren eines Buckets für Benachrichtigungen (SNS-Thema oder SQS-Warteschlange)

Sie können Amazon-S3-Benachrichtigungen über den Amazon Simple Notification Service (Amazon SNS) oder den Amazon Simple Queue Service (Amazon SQS) erhalten. In diesem Walkthrough fügen Sie Ihrem Bucket eine Benachrichtigungskonfiguration mit einem Amazon SNS-Thema und einer Amazon SQS-Warteschlange hinzu.

Anmerkung

FIFO-Warteschlangen (First-In-First-Out) von Amazon Simple Queue Service werden nicht als Ziel für Amazon-S3-Ereignisbenachrichtigungen unterstützt. Um eine Benachrichtigung für ein Amazon S3-Ereignis an eine Amazon SQS-FIFO-Warteschlange zu senden, können Sie Amazon verwenden EventBridge. Weitere Informationen finden Sie unter Aktivieren von Amazon EventBridge.

Themen

Walkthrough-Übersicht
Schritt 1: Erstellen einer Amazon SQS-Warteschlange
Schritt 2: Erstellen eines Amazon SNS-Themas
Schritt 3: Hinzufügen einer Benachrichtigungskonfiguration zu Ihrem Bucket
Schritt 4: Testen der Einrichtung

Walkthrough-Übersicht

Dieser Walkhrough hilft Ihnen bei folgenden Aufgaben:

Veröffentlichung von Ereignissen des Typs s3:ObjectCreated:* in einer Amazon SQS-Warteschlange.
Veröffentlichung von Ereignissen des Typs s3:ReducedRedundancyLostObject in einem Amazon SNS-Thema.

Weitere Informationen zur Benachrichtigungskonfiguration finden Sie unter Verwenden von Amazon SQS, Amazon SNS und Lambda

Alle diese Schritte können Sie auf der Konsole erledigen, ohne Code schreiben zu müssen. Darüber hinaus werden Codebeispiele bereitgestellt, die AWS SDKs für Java und .NET verwenden, um Ihnen zu helfen, Benachrichtigungskonfigurationen programmgesteuert hinzuzufügen.

In dieser Vorgehensweise werden die folgenden Schritte beschrieben:

Erstellen einer Amazon SQS-Warteschlange

Mit der Amazon-SQS-Konsole erstellen Sie eine SQS-Warteschlange. Sie können auf alle Meldungen zugreifen, die Amazon S3 programmgesteuert an die Warteschlange sendet. Für diese schrittweise Anleitung überprüfen Sie die Benachrichtigungsmitteilungen in der Konsole.

Sie ordnen der Warteschlange eine Zugriffsrichtlinie zu, um Amazon S3 die Berechtigung zu erteilen, Meldungen zu veröffentlichen.
Erstellen Sie ein Amazon SNS-Thema.

Erstellen Sie mit der Amazon-SNS-Konsole ein SNS-Thema und abonnieren Sie das Thema. Auf diese Weise werden alle darin veröffentlichten Ereignisse an Sie weitergegeben. Sie geben als Kommunikationsprotokoll E-Mail an. Nachdem Sie ein Thema erstellt haben, sendet Amazon SNS eine E-Mail. Sie verwenden den Link in der E-Mail, um das Abonnement des Themas zu bestätigen.

Sie ordnen dem Thema eine Zugriffsrichtlinie zu, um Amazon S3 die Berechtigung zu erteilen, Meldungen zu veröffentlichen.
Fügen Sie einem Bucket eine Benachrichtigungskonfiguration hinzu.

Schritt 1: Erstellen einer Amazon SQS-Warteschlange

Führen Sie die Schritte zum Erstellen und Abonnieren einer Amazon Simple Queue Service (Amazon SQS)-Warteschlange (Amazon SQS) aus.

Erstellen Sie mit der Amazon SQS-Konsole eine Warteschlange. Anweisungen finden Sie unter Erste Schritte mit Amazon SQS im Amazon Simple Queue Service-Entwicklerhandbuch.

Ersetzen Sie die der Warteschlange zugeordnete Zugriffsrichtlinie durch die folgende Richtlinie.

Wählen Sie in der Amazon-SQS-Konsole in der Liste Warteschlangen den Warteschlangennamen aus.
Wählen Sie im Tab Zugriffsrichtlinie die Option Bearbeiten aus.

Ersetzen Sie die Zugriffsrichtlinie, die der Warteschlange angefügt ist. Geben Sie darin Ihren Amazon-SQS-ARN, den Quell-Bucket-Namen und die Bucket-Eigentümer-Konto-ID an.


{
    "Version": "2012-10-17",
    "Id": "example-ID",
    "Statement": [
        {
            "Sid": "example-statement-ID",
            "Effect": "Allow",
            "Principal": {
                "Service": "s3.amazonaws.com"
            },
            "Action": [
                "SQS:SendMessage"
            ],
            "Resource": "SQS-queue-ARN",
            "Condition": {
                "ArnLike": {
                    "aws:SourceArn": "arn:aws:s3:*:*:awsexamplebucket1"
                },
                "StringEquals": {
                    "aws:SourceAccount": "bucket-owner-account-id"
                }
            }
        }
    ]
}

Wählen Sie Speichern.

(Optional) Wenn es sich bei der Amazon SQS-Warteschlange oder dem Amazon SNS-Thema um eine serverseitige Verschlüsselung handelt, die mit AWS Key Management Service (AWS KMS) aktiviert ist, fügen Sie die folgende Richtlinie zum zugehörigen vom Kunden verwalteten Schlüssel für symmetrische Verschlüsselung hinzu.

Sie müssen die Richtlinie einem von Kunden verwalteten Schlüssel hinzufügen, da Sie den AWS -verwalteten Schlüssel für Amazon SQS oder Amazon SNS nicht ändern können.
```
{
    "Version": "2012-10-17",
    "Id": "example-ID",
    "Statement": [
        {
            "Sid": "example-statement-ID",
            "Effect": "Allow",
            "Principal": {
                "Service": "s3.amazonaws.com"
            },
            "Action": [
                "kms:GenerateDataKey",
                "kms:Decrypt"
            ],
            "Resource": "*"
        }
    ]
}
```
Weitere Informationen zur Verwendung von SSE für Amazon SQS und Amazon SNS mit AWS KMS finden Sie hier:
- Schlüsselverwaltung im Amazon Simple Notification Service-Entwicklerhandbuch.
- Schlüsselverwaltung im Amazon Simple Queue Service-Entwicklerhandbuch.
Notieren Sie den ARN der Warteschlange.

Die SQS-Warteschlange, die Sie erstellt haben, ist eine weitere Ressource in Ihrem AWS-Konto. Es hat einen eindeutigen Amazon-Ressourcennamen (ARN). Sie benötigen diesen ARN im nächsten Schritt. Der ARN muss das folgende Format aufweisen:
```
arn:aws:sqs:aws-region:account-id:queue-name
```

Gehen Sie wie folgt vor, um ein Amazon SNS-Thema zu erstellen und zu abonnieren.

Erstellen Sie mit der Amazon SNS-Konsole ein Thema. Eine Anleitung finden Sie unter Amazon SNS-Thema anlegen im Amazon Simple Notification Service-Entwicklerhandbuch.
Abonnieren Sie das Thema. Für diese Übung geben Sie email als Kommunikationsprotokoll an. Eine Anleitung finden Sie unter Amazon SNS-Thema abonnieren im Amazon Simple Notification Service-Entwicklerhandbuch.

Sie erhalten eine E-Mail, in der Sie aufgefordert werden, das Abonnement des Themas zu bestätigen. Bestätigen Sie das Abonnement.

Ersetzen Sie die dem Thema zugeordnete Zugriffsrichtlinie durch die folgende Richtlinie. Geben Sie darin Ihren SNS-Themen-ARN, den Bucket-Namen und die Konto-ID des Bucket-Eigentümers an.


{
    "Version": "2012-10-17",
    "Id": "example-ID",
    "Statement": [
        {
            "Sid": "Example SNS topic policy",
            "Effect": "Allow",
            "Principal": {
                "Service": "s3.amazonaws.com"
            },
            "Action": [
                "SNS:Publish"
            ],
            "Resource": "SNS-topic-ARN",
            "Condition": {
                "ArnLike": {
                    "aws:SourceArn": "arn:aws:s3:*:*:bucket-name"
                },
                "StringEquals": {
                    "aws:SourceAccount": "bucket-owner-account-id"
                }
            }
        }
    ]
}

Notieren Sie den ARN des Themas.

Das von Ihnen erstellte SNS-Thema ist eine weitere Ressource in Ihrem und hat einen AWS-Konto eindeutigen ARN. Sie benötigen diesen ARN im nächsten Schritt. Der ARN hat das folgende Format:
```
arn:aws:sns:aws-region:account-id:topic-name
```

Schritt 3: Hinzufügen einer Benachrichtigungskonfiguration zu Ihrem Bucket

Sie können Bucket-Benachrichtigungen entweder über die Amazon S3-Konsole oder programmgesteuert über AWS SDKs aktivieren. Wählen Sie eine der Optionen für die Konfiguration von Benachrichtigungen über Ihren Bucket. Dieser Abschnitt zeigt Beispiele für die Verwendung des AWS -SDKs for Java und .NET.

Option A: Aktivieren von Benachrichtigungen über einen Bucket unter Verwendung der Konsole

Fügen Sie mithilfe der Amazon-S3-Konsole eine Benachrichtigungskonfiguration hinzu, die Amazon S3 zu Folgendem auffordert:

Veröffentlichen von Ereignissen des Typs All object create events (Alle Objekterstellungsereignisse) in Ihrer Amazon SQS-Warteschlange.
Veröffentlichen von Ereignissen des Typs Object in RRS lost (Objekt in RRS verloren) in Ihrem Amazon SNS-Thema.

Nachdem Sie die Benachrichtigungskonfiguration gespeichert haben, veröffentlicht Amazon S3 eine Testmeldung, die Sie per E-Mail erhalten.

Anweisungen finden Sie unter Aktivieren und Konfigurieren von Ereignis-Benachrichtigungen mit der Amazon-S3-Konsole.

Option B: Aktivieren von Benachrichtigungen für einen Bucket mithilfe der AWS SDKs

.NET

Das folgende C#-Codebeispiel zeigt ein vollständiges Listing, das einem Bucket eine Benachrichtigungskonfiguration hinzufügt. Sie müssen den Code aktualisieren und Ihren Bucket-Namen und den ARN des SNS-Themas angeben. Anweisungen zum Erstellen und Testen eines funktionierenden Beispiels finden Sie unter Ausführen der .NET-Codebeispiele für Amazon S3.


using Amazon;
using Amazon.S3;
using Amazon.S3.Model;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;

namespace Amazon.DocSamples.S3
{
    class EnableNotificationsTest
    {
        private const string bucketName = "*** bucket name ***";
        private const string snsTopic = "*** SNS topic ARN ***";
        private const string sqsQueue = "*** SQS topic ARN ***";
        // Specify your bucket region (an example region is shown).
        private static readonly RegionEndpoint bucketRegion = RegionEndpoint.USWest2;
        private static IAmazonS3 client;

        public static void Main()
        {
            client = new AmazonS3Client(bucketRegion);
            EnableNotificationAsync().Wait();
        }

        static async Task EnableNotificationAsync()
        {
            try
            {
               PutBucketNotificationRequest request = new PutBucketNotificationRequest
                {
                    BucketName = bucketName
                };

                TopicConfiguration c = new TopicConfiguration
                {
                    Events = new List<EventType> { EventType.ObjectCreatedCopy },
                    Topic = snsTopic
                };
                request.TopicConfigurations = new List<TopicConfiguration>();
                request.TopicConfigurations.Add(c);
                request.QueueConfigurations = new List<QueueConfiguration>();
                request.QueueConfigurations.Add(new QueueConfiguration()
                {
                    Events = new List<EventType> { EventType.ObjectCreatedPut },
                    Queue = sqsQueue
                });
                
                PutBucketNotificationResponse response = await client.PutBucketNotificationAsync(request);
            }
            catch (AmazonS3Exception e)
            {
                Console.WriteLine("Error encountered on server. Message:'{0}' ", e.Message);
            }
            catch (Exception e)
            {
                Console.WriteLine("Unknown error encountered on server. Message:'{0}' ", e.Message);
            }
        }
    }
}

Java

Die folgende Beispiel veranschaulicht, wie Sie einem Bucket eine Benachrichtigungskonfiguration hinzufügen. Anweisungen zum Erstellen und Testen eines funktionierenden Beispiels finden Sie unter Testen der Java-Codebeispiele für Amazon S3.



import com.amazonaws.AmazonServiceException;
import com.amazonaws.SdkClientException;
import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.*;

import java.io.IOException;
import java.util.EnumSet;

public class EnableNotificationOnABucket {

    public static void main(String[] args) throws IOException {
        String bucketName = "*** Bucket name ***";
        Regions clientRegion = Regions.DEFAULT_REGION;
        String snsTopicARN = "*** SNS Topic ARN ***";
        String sqsQueueARN = "*** SQS Queue ARN ***";

        try {
            AmazonS3 s3Client = AmazonS3ClientBuilder.standard()
                    .withCredentials(new ProfileCredentialsProvider())
                    .withRegion(clientRegion)
                    .build();
            BucketNotificationConfiguration notificationConfiguration = new BucketNotificationConfiguration();

            // Add an SNS topic notification.
            notificationConfiguration.addConfiguration("snsTopicConfig",
                    new TopicConfiguration(snsTopicARN, EnumSet.of(S3Event.ObjectCreated)));

            // Add an SQS queue notification.
            notificationConfiguration.addConfiguration("sqsQueueConfig",
                    new QueueConfiguration(sqsQueueARN, EnumSet.of(S3Event.ObjectCreated)));

            // Create the notification configuration request and set the bucket notification
            // configuration.
            SetBucketNotificationConfigurationRequest request = new SetBucketNotificationConfigurationRequest(
                    bucketName, notificationConfiguration);
            s3Client.setBucketNotificationConfiguration(request);
        } catch (AmazonServiceException e) {
            // The call was transmitted successfully, but Amazon S3 couldn't process
            // it, so it returned an error response.
            e.printStackTrace();
        } catch (SdkClientException e) {
            // Amazon S3 couldn't be contacted for a response, or the client
            // couldn't parse the response from Amazon S3.
            e.printStackTrace();
        }
    }
}

Schritt 4: Testen der Einrichtung

Jetzt können Sie die Einrichtung testen, indem Sie ein Objekt in Ihren Bucket hochladen und die Ereignis-Benachrichtigung in der Amazon-SQS-Konsole überprüfen. Anweisungen finden Sie unter Empfangen einer Nachricht im Abschnitt "Erste Schritte" im Amazon Simple Queue Service-Entwicklerhandbuch.

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

Aktivieren von Benachrichtigungen in der S3-Konsole

Konfigurieren von Benachrichtigungen mithilfe der Objektschlüsselnamenfilterung