Konfigurieren der Replikation für Quell- und Ziel-Buckets im Eigentum desselben Kontos

Die Replikation ist das automatische, asynchrone Kopieren von Objekten über Buckets hinweg in derselben oder einer anderen AWS-Regionen. Sie kopiert neu erstellte Objekte und Objektaktualisierungen aus einem Quell-Bucket in einen Ziel-Bucket oder mehrere Ziel-Buckets. Weitere Informationen finden Sie unter Replizieren von Objekten.

Wenn Sie die Replikation konfigurieren, fügen Sie dem Quell-Bucket Replikationsregeln hinzu. Replikationsregeln definieren, welche Quell-Bucket-Objekte repliziert werden sollen, und den Ziel-Bucket/die Ziel-Buckets, in dem/denen die replizierten Objekte gespeichert werden sollen. Sie können eine Regel erstellen, um alle Objekte in einem Bucket oder eine Untermenge von Objekten mit einem spezifischen Schlüsselnamenpräfixen, einem oder mehreren Objekt-Markierungen oder beidem zu replizieren. Ein Ziel-Bucket kann sich in derselben AWS-Konto wie der Quell-Bucket oder in einem anderen Konto befinden.

Wenn Sie angeben, dass eine Objektversions-ID gelöscht werden soll, löscht Amazon S3 diese Objektversion im Quell-Bucket. Es repliziert die Löschung aber nicht im Ziel-Bucket. Anders ausgedrückt: Dieselbe Objektversion wird im Ziel-Bucket nicht gelöscht. Dies schützt Daten vor missbräuchlichen Löschungen.

Wenn Sie einem Bucket eine Replikationsregel hinzufügen, ist diese standardmäßig aktiviert, sodass sie ausgeführt wird, sobald Sie sie speichern.

In diesem Beispiel richten Sie eine Replikation für Quell- und Ziel-Buckets ein, die demselben AWS-Konto gehören. Beispiele für die Verwendung der Amazon S3-Konsole, der AWS Command Line Interface (AWS CLI) und der AWS SDK for Java und AWS SDK for .NET.

Gehen Sie folgendermaßen vor, um eine Replikationsregel zu konfigurieren, wenn sich der Ziel-Bucket in derselben AWS-Konto wie der Quell-Bucket befindet.

Wenn sich der Ziel-Bucket in einem anderen Konto als der Quell-Bucket befindet, müssen Sie eine Bucket-Richtlinie für den Ziel-Bucket hinzufügen, um dem Eigentümer des Quell-Bucket-Kontos die Berechtigung zum Replizieren von Objekten in der Ziel-Bucket zu erteilen. Weitere Informationen finden Sie unter Erteilen von Berechtigungen, wenn sich der Quell- und der Ziel-Bucket im Besitz verschiedener befinden AWS-Konten.

Melden Sie sich bei der an AWS Management Console und öffnen Sie die Amazon S3-Konsole unter https://console.aws.amazon.com/s3/.
Wählen Sie im linken Navigationsbereich Buckets aus.
Wählen Sie in der Liste Buckets den Namen des von Ihnen erstellten Buckets aus.
Wählen Sie die Registerkarte Verwaltung aus, scrollen Sie nach unten zu Replikationsregeln und wählen Sie dann Replikationsregel erstellen aus.
Geben Sie im Abschnitt Replikationsregelkonfiguration unter Name der Replikationsregel einen Namen für Ihre Regel ein, um die Regel später leichter identifizieren zu können. Der Name ist erforderlich und muss innerhalb des Buckets eindeutig sein.
In Status (Status)ist Enabled (Aktiviert) standardmäßig ausgewählt. Eine aktivierte Regel wird ausgeführt, sobald Sie speichern. Wenn Sie die Regel später aktivieren möchten, wählen Sie Deaktiviert aus.
Wenn es bereits Replikationsregeln für den Bucket gibt, werden Sie angewiesen, eine Priorität für die Regel festzulegen. Sie müssen eine Priorität für die Regel festlegen, um Konflikte zu vermeiden, die durch Objekte verursacht werden, die mehreren Regeln unterliegen. Wenn sich Regeln überschneiden, verwendet Amazon S3 die Regelpriorität, um die Regel zu ermitteln, die angewendet werden muss. Je höher die Zahl, desto höher die Priorität. Weitere Informationen zur Priorität von Regeln finden Sie unter Replikations-Konfiguration.
Unter Quell-Bucket stehen Ihnen folgende Optionen zum Festlegen der Replikationsquelle zur Verfügung:
- Um den gesamten Bucket zu replizieren, wählen Sie Apply to all objects in the bucket (Auf alle Objekte im Bucket anwenden).
- Um alle Objekte zu replizieren, die dasselbe Präfix haben, wählen Sie Limit the scope of this rule using one or more filters (Geltungsbereich dieser Regel mit einem oder mehreren Filtern einschränken). Dies beschränkt die Replikation auf alle Objekte, deren Namen mit dem von Ihnen angegebenen Präfix beginnen (z. B. pictures). Geben Sie ein Präfix in das Feld Präfix ein.
  
  Anmerkung
  Wenn Sie ein Präfix eingeben, das den Namen eines Ordners darstellt, müssen Sie / (Schrägstrich) als letztes Zeichen eingeben (z. B. pictures/).
- Um alle Objekte mit einem oder mehreren Objekt-Tags zu replizieren, wählen Sie Tag hinzufügen aus und geben Sie das Schlüssel-Wert-Paar in die Felder ein. Wiederholen Sie den Vorgang, um ein weiteres Tag hinzuzufügen. Sie können ein Präfix und Markierungen kombinieren. Weitere Informationen über Objekt-Markierungen finden Sie unter Kategorisieren des Speichers mithilfe von Markierungen.
Das neue XML-Schema für die Replikationskonfiguration unterstützt das Filtern nach Präfix und Tag und die Priorisierung von Regeln. Weitere Informationen über das neue Schema finden Sie unter Abwärtskompatibilität. Weitere Informationen über das mit der Amazon-S3-API verwendete XML, das hinter der Benutzeroberfläche funktioniert, finden Sie unter Replikations-Konfiguration. Das neue Schema wird als XML V2 für die Replikationskonfiguration beschrieben.
Wählen Sie unter Ziel den Bucket aus, in den Amazon S3 Objekte replizieren soll.

Anmerkung
Die Anzahl der Ziel-Buckets ist auf die Anzahl der AWS-Regionen in einer bestimmten Partition begrenzt. Eine Partition ist eine Gruppierung von Regionen. hat AWS derzeit drei Partitionen: aws (Standardregionen), aws-cn (China-Regionen) und aws-us-gov (AWS GovCloud (US) Regionen). Sie können Service Quotas verwenden, um eine Erhöhung Ihres Ziel-Bucket-Kontingents anzufordern.
- Um in einen Bucket oder mehrere Buckets in Ihrem Konto zu replizieren, wählen Sie Bucket in diesem Konto wählen aus und geben Sie die Ziel-Bucket-Namen ein oder suchen Sie danach.
- Um in einen Bucket oder mehrere Buckets in einem anderen zu replizieren AWS-Konto, wählen Sie Bucket in einem anderen Konto angeben und geben Sie die Konto-ID des Ziel-Buckets und den Bucket-Namen ein.
  
  Wenn sich das Ziel in einem anderen Konto als der Quell-Bucket befindet, müssen Sie eine Bucket-Richtlinie für die Ziel-Buckets hinzufügen, um dem Eigentümer des Quell-Bucket-Kontos die Berechtigung zum Replizieren von Objekten zu erteilen. Weitere Informationen finden Sie unter Erteilen von Berechtigungen, wenn sich der Quell- und der Ziel-Bucket im Besitz verschiedener befinden AWS-Konten.
  
  Wenn Sie eine leichtere Standardisierung der Eigentümerschaft für neue Objekte im Ziel-Bucket ermöglichen möchten, wählen Sie Objekteigentümerschaft in Eigentümer des Ziel-Buckets ändern aus. Weitere Informationen zu dieser Option finden Sie unter Weitere Informationen finden Sie unter Steuern des Eigentums an Objekten und Deaktivieren von ACLs für Ihren Bucket..
Anmerkung
Wenn die Versionssteuerung für den Ziel-Bucket nicht aktiviert ist, erhalten Sie eine Warnmeldung, die die Schaltfläche Versionierung aktivieren enthält. Wählen Sie diese Schaltfläche, um das Versioning für den Bucket zu aktivieren.
Richten Sie eine AWS Identity and Access Management (IAM)-Rolle ein, die Amazon S3 annehmen kann, um Objekte in Ihrem Namen zu replizieren.

Um eine IAM-Rolle einzurichten, wählen Sie im Abschnitt IAM-Rolle eine der folgenden Optionen aus der Dropdown-Liste IAM-Rolle aus:
- Wir empfehlen Ihnen, Create new role (Neue Rolle erstellen) auszuwählen, um Amazon S3 anzuweisen, eine neue IAM-Rolle für Sie zu erstellen. Wenn Sie die Regel speichern, wird eine neue Richtlinie für die IAM-Rolle erstellt, die mit den von Ihnen ausgewählten Quell- und Ziel-Buckets übereinstimmt.
- Sie haben auch die Möglichkeit eine vorhandene IAM-Rolle zu verwenden. In diesem Fall müssen Sie eine Rolle auswählen, die Amazon S3 die erforderlichen Berechtigungen für die Replikation gewährt. Die Replikation schlägt fehl, wenn diese Rolle Amazon S3 keine ausreichenden Berechtigungen gewährt, um Ihre Replikationsregel zu befolgen.
Wichtig
Wenn Sie eine Replikationsregel zu einem Bucket hinzufügen, benötigen Sie die Berechtigung iam:PassRole zum Übergeben der IAM-Rolle, die Amazon S3 Replikationsberechtigungen erteilt. Weitere Informationen finden Sie unter Erteilen von Berechtigungen, mit denen ein Benutzer eine Rolle an einen AWS-Serviceübergeben kann im IAM-Benutzerhandbuch.
Um Objekte im Quell-Bucket zu replizieren, die mit serverseitiger Verschlüsselung mit AWS Key Management Service (AWS KMS)-Schlüsseln (SSE-KMS) verschlüsselt sind, wählen Sie unter Verschlüsselung die Option Mit verschlüsselte Objekte replizieren aus AWS KMS. Unter AWS KMS -Schlüssel für die Verschlüsselung von Zielobjekten befinden sich die Quellschlüssel, deren Verwendung Sie der Replikation erlauben. Alle Quell-KMS-Schlüssel sind standardmäßig enthalten. Um die KMS-Schlüsselauswahl einzuschränken, können Sie einen Alias oder eine Schlüssel-ID auswählen.

Mit verschlüsselte Objekte AWS KMS keys , die Sie nicht auswählen, werden nicht repliziert. Ein KMS-Schlüssel oder eine Gruppe von KMS-Schlüsseln wird für Sie ausgewählt, aber Sie können die KMS-Schlüssel auch selbst auswählen. Informationen zur Verwendung von AWS KMS mit der Replikation finden Sie unter Replizieren von mit serverseitiger Verschlüsselung (SSE-C, SSE-S3, SSE-KMS, DSSE-KMS) erstellten Objekten.

Wichtig
Wenn Sie Objekte replizieren, die mit verschlüsselt sind AWS KMS, verdoppelt sich die AWS KMS Anforderungsrate in der Quellregion und erhöht sich in der Zielregion um den gleichen Betrag. Diese erhöhten Aufrufraten für AWS KMS sind auf die Art und Weise zurückzuführen, wie Daten mithilfe des KMS-Schlüssels erneut verschlüsselt werden, den Sie für die Zielregion der Replikation definieren. AWS KMS hat ein Anforderungsratenkontingent, das pro aufrufendem Konto und Region gilt. Informationen zu den standardmäßigen Kontingenten finden Sie unter AWS KMS -Kontingente – Anforderungen pro Sekunde: variabel im AWS Key Management Service Entwicklerhandbuch.
Wenn Ihre aktuelle Amazon S3-PUTObjektanforderungsrate während der Replikation mehr als die Hälfte des AWS KMS Standardratenlimits für Ihr Konto beträgt, empfehlen wir Ihnen, eine Erhöhung Ihres AWS KMS Anforderungsratenkontingents anzufordern. Wenn Sie eine Erhöhung anfordern möchten, erstellen Sie einen Fall im AWS Support -Center unter Contact Us (Kontakt). Angenommen, Ihre aktuelle PUT Objektanforderungsrate beträgt 1 000 Anforderungen pro Sekunde und Sie verwenden , AWS KMS um Ihre Objekte zu verschlüsseln. In diesem Fall empfehlen wir Ihnen, AWS Support zu bitten, Ihr AWS KMS Ratenlimit sowohl in Ihrer Quell- als auch in Ihrer Zielregion (falls unterschiedlich) auf 2 500 Anforderungen pro Sekunde zu erhöhen, um sicherzustellen, dass es keine Drosselung durch gibt AWS KMS.
Um Ihre PUT Objektanforderungsrate im Quell-Bucket anzuzeigen, sehen Sie sich PutRequests in den Amazon- CloudWatch Anforderungsmetriken für Amazon S3 an. Weitere Informationen zum Anzeigen von CloudWatch Metriken finden Sie unter Verwenden der S3-Konsole.

Wenn Sie mit verschlüsselte Objekte replizieren möchten AWS KMS, gehen Sie wie folgt vor:
1. Geben Sie unter AWS KMS key für die Verschlüsselung von Zielobjekten Ihren KMS-Schlüssel auf eine der folgenden Arten an:
  - Wenn Sie aus einer Liste verfügbarer KMS-Schlüssel auswählen möchten, wählen Sie Aus Ihren AWS KMS keys wählen und anschließend den KMS-Schlüssel in der Liste der verfügbaren Schlüssel aus.
    
    Sowohl die Von AWS verwalteter Schlüssel (aws/s3) als auch Ihre vom Kunden verwalteten Schlüssel werden in dieser Liste angezeigt. Weitere Informationen über vom Kunden verwaltete Schlüssel finden Sie unter Kundenschlüssel und AWS -Schlüssel im Entwicklerhandbuch zu AWS Key Management Service .
  - Wählen Sie zum Eingeben des Amazon-Ressourcennamens (ARN) des KMS-Schlüssels AWS KMS key -ARN eingeben aus und geben Sie Ihren KMS-Schlüssel-ARN in das angezeigte Feld ein. Dadurch werden die Replikate im Ziel-Bucket verschlüsselt. Sie finden den ARN für Ihren KMS-Schlüssel in der IAM-Konsole unter Verschlüsselungsschlüssel.
  - Um einen neuen kundenverwalteten Schlüssel in der AWS KMS Konsole zu erstellen, wählen Sie KMS-Schlüssel erstellen aus.
    
    Weitere Informationen zum Erstellen eines AWS KMS key finden Sie unter Erstellen von Schlüsseln im AWS Key Management Service -Entwicklerhandbuch.
  Wichtig
  Sie können nur KMS-Schlüssel verwenden, die in derselben AWS-Region wie der Bucket aktiviert sind. Wenn Sie Aus Ihren KMS-Schlüsseln wählen auswählen, werden in der S3-Konsole nur 100 KMS-Schlüssel pro Region aufgeführt. Wenn Sie über mehr als 100 KMS-Schlüssel in derselben Region verfügen, können Sie nur die ersten 100 KMS-Schlüssel in der S3-Konsole sehen. Um einen nicht in der Konsole aufgeführten KMS-Schlüssel zu verwenden, wählen Sie AWS KMS key -ARN eingeben aus und geben Sie Ihren KMS-Schlüssel-ARN ein.
  Wenn Sie einen AWS KMS key für die serverseitige Verschlüsselung in Amazon S3 verwenden, müssen Sie einen KMS-Schlüssel mit symmetrischer Verschlüsselung auswählen. Amazon S3 unterstützt nur KMS-Schlüssel mit symmetrischer Verschlüsselung und keine asymmetrischen KMS-Schlüssel. Weitere Informationen finden Sie unter Erkennen von symmetrischen und asymmetrischen KMS-Schlüsseln im Entwicklerhandbuch zu AWS Key Management Service .
  
  Weitere Informationen zum Erstellen eines AWS KMS key finden Sie unter Erstellen von Schlüsseln im AWS Key Management Service -Entwicklerhandbuch. Weitere Informationen zur Verwendung von AWS KMS mit Amazon S3 finden Sie unter Verwenden der serverseitigen Verschlüsselung mit - AWS KMS Schlüsseln (SSE-KMS).
Wenn Sie Ihre Daten in eine bestimmte Speicherklasse im Ziel replizieren wollen, wählen Sie unter Zielspeicherklasse die Option Speicherklasse für die replizierten Objekte ändern aus. Anschließend wählen Sie die Speicherklasse, die Sie für die replizierten Objekte im Ziel verwenden wollen. Wenn Sie diese Option nicht auswählen, ist die Speicherklasse für replizierte Objekte dieselbe Klasse wie für die ursprünglichen Objekte.
Beim Festlegen der zusätzlichen Replikationsoptionen haben Sie folgende zusätzliche Optionen:
- Wenn Sie die Begrenzung der S3-Replikationszeit (S3 RTC) in Ihrer Replikationskonfiguration aktivieren möchten, wählen Sie Replikationszeitkontrolle (Replication Time Control, RTC) aus. Weitere Informationen zu dieser Option finden Sie unter Erfüllen der Compliance-Anforderungen mit S3-Replikationszeitkontrolle (S3 RTC).
- Wenn Sie S3-Replikationsmetriken in Ihrer Replikationskonfiguration aktivieren möchten, wählen Sie Replication metrics and events (Replikationsmetriken und -ereignisse) aus. Weitere Informationen finden Sie unter Überwachen des Fortschritts mit Replikationsmetriken und S3-Ereignisbenachrichtigungen.
- Wenn Sie die Löschmarkierungs-Replikation in Ihrer Replikations-Konfiguration aktivieren möchten, wählen Sie Markierungsreplikation löschen aus. Weitere Informationen finden Sie unter Replizieren von Löschmarkierungen auf Buckets.
- Wenn Sie die Synchronisierung der Amazon-S3-Replikatänderung in Ihrer Replikations-Konfiguration aktivieren möchten, wählen Sie Synchronisierung der Replikatänderung aus. Weitere Informationen finden Sie unter Replizieren von Metadatenänderungen mit der Synchronisierung von Amazon-S3-Replikatänderungen.
Anmerkung
Wenn Sie S3-RTC- oder S3-Replikationsmetriken verwenden, fallen zusätzliche Gebühren an.
Zum Abschluss wählen Sie Save (Speichern).
Nachdem Sie Ihre Regel gespeichert haben, können Sie Ihre Regel bearbeiten, aktivieren, deaktivieren oder löschen, indem Sie Ihre Regel auswählen und Edit rule (Regel bearbeiten) wählen.

Gehen Sie wie folgt vor, um die AWS CLI zum Einrichten der Replikation zu verwenden AWS-Konto, wenn sich Quell- und Ziel-Bucket im Besitz desselben befinden:

Erstellen Sie Quell- und Ziel-Buckets
Aktivieren Sie das Versioning für die Buckets
Erstellen Sie eine IAM-Rolle welche Amazon S3 die Berechtigungen erteilt, Objekte zu replizieren.
Fügen Sie die Replikationskonfiguration zum Quell-Bucket hinzu

Um die Einrichtung zu prüfen, testen Sie sie.

So richten Sie die Replikation ein, wenn sich Quell- und Ziel-Bucket im Besitz desselben befinden AWS-Konto

Richten Sie das Anmeldeinformationsprofil für die AWS CLI ein. In diesem Beispiel verwenden wir den Profilnamen acctA. Informationen zum Einrichten der Anmeldeinformations-Profile finden Sie unter Named Profiles (Benannte Profile) im AWS Command Line Interface -Benutzerhandbuch.

Wichtig
Das Profil, das Sie für diese Übung verwenden, muss über die nötigen Berechtigungen verfügen. Beispielsweise legen Sie in der Replikations-Konfiguration die IAM-Rolle fest, die Amazon S3 annehmen kann. Dies können Sie nur tun, wenn das verwendete Profil über die iam:PassRole-Berechtigung verfügt. Weitere Informationen finden Sie unter Erteilen von Berechtigungen, mit denen ein Benutzer eine Rolle an einen AWS -Service übergeben kann im IAM-Benutzerhandbuch. Wenn Sie zur Erstellung eines benannten Profils die Anmeldeinformationen eines Administrators verwenden, können Sie alle Aufgaben durchführen.

Erstellen Sie einen source-Bucket und aktivieren Sie dafür das Versioning. Der folgende Code erstellt einen source-Bucket in der Region USA Ost (Nord-Virginia) (us-east-1).


aws s3api create-bucket \
--bucket source \
--region us-east-1 \
--profile acctA


aws s3api put-bucket-versioning \
--bucket source \
--versioning-configuration Status=Enabled \
--profile acctA

Erstellen Sie einen destination-Bucket und aktivieren Sie dafür das Versioning. Der folgende Code erstellt einen destination-Bucket in der Region US West (Oregon) (us-west-2).

Anmerkung
Um die Replikationskonfiguration einzurichten, wenn sich Quell- und Ziel-Bucket im selben befinden AWS-Konto, verwenden Sie dasselbe Profil. Dieses Beispiel verwendet acctA. Um die Replikationskonfiguration zu testen, wenn sich die Buckets im Besitz verschiedener befinden AWS-Konten, geben Sie für jede unterschiedliche Profile an. In diesem Beispiel verwenden wir das Profil acctB für den Ziel-Bucket.
```
aws s3api create-bucket \
--bucket destination \
--region us-west-2 \
--create-bucket-configuration LocationConstraint=us-west-2 \
--profile acctA
```
```
aws s3api put-bucket-versioning \
--bucket destination \
--versioning-configuration Status=Enabled \
--profile acctA
```

Erstellen Sie eine IAM-Rolle. Sie geben diese Rolle in der Replizierungskonfiguration an, die Sie später zum Quell-Bucket hinzufügen. Amazon S3 übernimmt diese Rolle, um Objekte in Ihrem Namen zu replizieren. Sie erstellen eine IAM-Rolle in zwei Schritten:

Erstellen Sie eine Rolle.
Fügen Sie eine Berechtigungsrichtlinie zur Rolle hinzu.

Erstellen Sie die IAM-Rolle.

Kopieren Sie die folgende Vertrauensrichtlinie und speichern Sie sie in einer Datei mit dem Namen s3-role-trust-policy.json im aktuellen Verzeichnis auf Ihrem lokalen Computer. Diese Richtlinie gewährt Amazon S3 Service-Prinzipal-Berechtigungen, um die Rolle anzunehmen.
```
{
   "Version":"2012-10-17",
   "Statement":[
      {
         "Effect":"Allow",
         "Principal":{
            "Service":"s3.amazonaws.com"
         },
         "Action":"sts:AssumeRole"
      }
   ]
}
```

Führen Sie den folgenden Befehl aus, um eine Rolle zu erstellen.


$ aws iam create-role \
--role-name replicationRole \
--assume-role-policy-document file://s3-role-trust-policy.json  \
--profile acctA

Fügen Sie eine Berechtigungsrichtlinie zur Rolle hinzu.

Kopieren Sie die folgende Berechtigungsrichtlinie und speichern Sie sie in einer Datei mit dem Namen s3-role-permissions-policy.json im aktuellen Verzeichnis auf Ihrem lokalen Computer. Diese Zugriffsrichtlinie erteilt Berechtigungen für verschiedene Amazon-S3-Bucket- und -Objektaktionen.


{
   "Version":"2012-10-17",
   "Statement":[
      {
         "Effect":"Allow",
         "Action":[
            "s3:GetObjectVersionForReplication",
            "s3:GetObjectVersionAcl",
            "s3:GetObjectVersionTagging"
         ],
         "Resource":[
            "arn:aws:s3:::source-bucket/*"
         ]
      },
      {
         "Effect":"Allow",
         "Action":[
            "s3:ListBucket",
            "s3:GetReplicationConfiguration"
         ],
         "Resource":[
            "arn:aws:s3:::source-bucket"
         ]
      },
      {
         "Effect":"Allow",
         "Action":[
            "s3:ReplicateObject",
            "s3:ReplicateDelete",
            "s3:ReplicateTags"
         ],
         "Resource":"arn:aws:s3:::destination-bucket/*"
      }
   ]
}

Führen Sie den folgenden Befehl aus, um eine Richtlinie zu erstellen und sie der Rolle anzufügen.


$ aws iam put-role-policy \
--role-name replicationRole \
--policy-document file://s3-role-permissions-policy.json \
--policy-name replicationRolePolicy \
--profile acctA

Fügen Sie eine Replikationskonfiguration zum source-Bucket hinzu.
1. Obwohl die Amazon S3-API eine Replikationskonfiguration als XML erfordert, AWS CLI erfordert die , dass Sie die Replikationskonfiguration als JSON angeben. Speichern Sie den folgenden JSON-Code in einer Datei mit dem Namen replication.json im lokalen Verzeichnis auf Ihrem Computer.
```
{
  "Role": "IAM-role-ARN",
  "Rules": [
    {
      "Status": "Enabled",
      "Priority": 1,
      "DeleteMarkerReplication": { "Status": "Disabled" },
      "Filter" : { "Prefix": "Tax"},
      "Destination": {
        "Bucket": "arn:aws:s3:::destination-bucket"
      }
    }
  ]
}
```
2. Aktualisieren Sie den JSON-Code, indem Sie Werte für die destination-bucket und IAM-role-ARN angeben. Speichern Sie die Änderungen.
3. Führen Sie den folgenden Befehl aus, um die Replikations-Konfiguration zu Ihrem Quell-Bucket hinzuzufügen. Stellen Sie sicher, dass Sie den Namen für den source-Bucket angeben.
```
$ aws s3api put-bucket-replication \
--replication-configuration file://replication.json \
--bucket source \
--profile acctA
```
Um die Replikationskonfiguration abzurufen, verwenden Sie den Befehl get-bucket-replication.
```
$ aws s3api get-bucket-replication \
--bucket source \
--profile acctA
```
Testen Sie das Setup in der Amazon-S3-Konsole:
1. Melden Sie sich bei der an AWS Management Console und öffnen Sie die Amazon S3-Konsole unter https://console.aws.amazon.com/s3/.
2. Erstellen Sie im source-Bucket einen Ordner mit dem Namen Tax.
3. Fügen Sie Beispielobjekte zum Tax-Ordner im source-Bucket hinzu.
  
  Anmerkung
  Die von Amazon S3 für die Replikation eines Objekts benötigte Zeit hängt von der Größe des Objekts ab. Weitere Informationen zum Anzeigen des Replikationsstatus finden Sie unter Abrufen von Replikationsstatusinformationen.
  
  Überprüfen Sie im destination-Bucket Folgendes:
  - Dass Amazon S3 die Objekte repliziert hat.
  - In den properties (Eigenschaften) des Objekts, dass der Replication Status (Replikationsstatus) auf Replica festgelegt ist (was es als Replikatobjekt kennzeichnet).
  - In den properties (Eigenschaften) des Objekts, dass im Berechtigungsabschnitt keine Berechtigungen aufgeführt sind. Dies bedeutet, dass sich das Replikat noch im Besitz des source-Bucket-Eigentümers befindet und der destination-Bucket-Eigentümer über keine Berechtigung auf dem Objektreplikat verfügt. Sie können eine optionale Konfiguration hinzufügen, um Amazon S3 anzuweisen, die Replikat-Eigentümerschaft zu ändern. Ein Beispiel finden Sie unter Ändern des Replikat-Eigentümers, wenn sich Quell- und Ziel-Buckets im Eigentum unterschiedlicher Konten befinden.

Verwenden Sie die folgenden Codebeispiele, um einem Bucket mit bzw. eine Replikationskonfiguration hinzuzufügen AWS SDK for Java AWS SDK for .NET.

Java

Das folgende Beispiel fügt eine Replikations-Konfiguration einem Bucket hinzu und ruft die Konfiguration anschließend ab und überprüft sie. 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.identitymanagement.AmazonIdentityManagement;
import com.amazonaws.services.identitymanagement.AmazonIdentityManagementClientBuilder;
import com.amazonaws.services.identitymanagement.model.CreateRoleRequest;
import com.amazonaws.services.identitymanagement.model.PutRolePolicyRequest;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3Client;
import com.amazonaws.services.s3.model.BucketReplicationConfiguration;
import com.amazonaws.services.s3.model.BucketVersioningConfiguration;
import com.amazonaws.services.s3.model.CreateBucketRequest;
import com.amazonaws.services.s3.model.DeleteMarkerReplication;
import com.amazonaws.services.s3.model.DeleteMarkerReplicationStatus;
import com.amazonaws.services.s3.model.ReplicationDestinationConfig;
import com.amazonaws.services.s3.model.ReplicationRule;
import com.amazonaws.services.s3.model.ReplicationRuleStatus;
import com.amazonaws.services.s3.model.SetBucketVersioningConfigurationRequest;
import com.amazonaws.services.s3.model.StorageClass;
import com.amazonaws.services.s3.model.replication.ReplicationFilter;
import com.amazonaws.services.s3.model.replication.ReplicationFilterPredicate;
import com.amazonaws.services.s3.model.replication.ReplicationPrefixPredicate;

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class CrossRegionReplication {

        public static void main(String[] args) throws IOException {
                Regions clientRegion = Regions.DEFAULT_REGION;
                String accountId = "*** Account ID ***";
                String roleName = "*** Role name ***";
                String sourceBucketName = "*** Source bucket name ***";
                String destBucketName = "*** Destination bucket name ***";
                String prefix = "Tax/";

                String roleARN = String.format("arn:aws:iam::%s:%s", accountId, roleName);
                String destinationBucketARN = "arn:aws:s3:::" + destBucketName;

                AmazonS3 s3Client = AmazonS3Client.builder()
                                .withCredentials(new ProfileCredentialsProvider())
                                .withRegion(clientRegion)
                                .build();

                createBucket(s3Client, clientRegion, sourceBucketName);
                createBucket(s3Client, clientRegion, destBucketName);
                assignRole(roleName, clientRegion, sourceBucketName, destBucketName);

                try {

                        // Create the replication rule.
                        List<ReplicationFilterPredicate> andOperands = new ArrayList<ReplicationFilterPredicate>();
                        andOperands.add(new ReplicationPrefixPredicate(prefix));

                        Map<String, ReplicationRule> replicationRules = new HashMap<String, ReplicationRule>();
                        replicationRules.put("ReplicationRule1",
                                        new ReplicationRule()
                                                        .withPriority(0)
                                                        .withStatus(ReplicationRuleStatus.Enabled)
                                                        .withDeleteMarkerReplication(
                                                                        new DeleteMarkerReplication().withStatus(
                                                                                        DeleteMarkerReplicationStatus.DISABLED))
                                                        .withFilter(new ReplicationFilter().withPredicate(
                                                                        new ReplicationPrefixPredicate(prefix)))
                                                        .withDestinationConfig(new ReplicationDestinationConfig()
                                                                        .withBucketARN(destinationBucketARN)
                                                                        .withStorageClass(StorageClass.Standard)));

                        // Save the replication rule to the source bucket.
                        s3Client.setBucketReplicationConfiguration(sourceBucketName,
                                        new BucketReplicationConfiguration()
                                                        .withRoleARN(roleARN)
                                                        .withRules(replicationRules));

                        // Retrieve the replication configuration and verify that the configuration
                        // matches the rule we just set.
                        BucketReplicationConfiguration replicationConfig = s3Client
                                        .getBucketReplicationConfiguration(sourceBucketName);
                        ReplicationRule rule = replicationConfig.getRule("ReplicationRule1");
                        System.out.println("Retrieved destination bucket ARN: "
                                        + rule.getDestinationConfig().getBucketARN());
                        System.out.println("Retrieved priority: " + rule.getPriority());
                        System.out.println("Retrieved source-bucket replication rule status: " + rule.getStatus());
                } 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();
                }
        }

        private static void createBucket(AmazonS3 s3Client, Regions region, String bucketName) {
                CreateBucketRequest request = new CreateBucketRequest(bucketName, region.getName());
                s3Client.createBucket(request);
                BucketVersioningConfiguration configuration = new BucketVersioningConfiguration()
                                .withStatus(BucketVersioningConfiguration.ENABLED);

                SetBucketVersioningConfigurationRequest enableVersioningRequest = new SetBucketVersioningConfigurationRequest(
                                bucketName, configuration);
                s3Client.setBucketVersioningConfiguration(enableVersioningRequest);

        }

        private static void assignRole(String roleName, Regions region, String sourceBucket, String destinationBucket) {
                AmazonIdentityManagement iamClient = AmazonIdentityManagementClientBuilder.standard()
                                .withRegion(region)
                                .withCredentials(new ProfileCredentialsProvider())
                                .build();
                StringBuilder trustPolicy = new StringBuilder();
                trustPolicy.append("{\\r\\n   ");
                trustPolicy.append("\\\"Version\\\":\\\"2012-10-17\\\",\\r\\n   ");
                trustPolicy.append("\\\"Statement\\\":[\\r\\n      {\\r\\n         ");
                trustPolicy.append("\\\"Effect\\\":\\\"Allow\\\",\\r\\n         \\\"Principal\\\":{\\r\\n            ");
                trustPolicy.append("\\\"Service\\\":\\\"s3.amazonaws.com\\\"\\r\\n         },\\r\\n         ");
                trustPolicy.append("\\\"Action\\\":\\\"sts:AssumeRole\\\"\\r\\n      }\\r\\n   ]\\r\\n}");

                CreateRoleRequest createRoleRequest = new CreateRoleRequest()
                                .withRoleName(roleName)
                                .withAssumeRolePolicyDocument(trustPolicy.toString());

                iamClient.createRole(createRoleRequest);

                StringBuilder permissionPolicy = new StringBuilder();
                permissionPolicy.append(
                                "{\\r\\n   \\\"Version\\\":\\\"2012-10-17\\\",\\r\\n   \\\"Statement\\\":[\\r\\n      {\\r\\n         ");
                permissionPolicy.append(
                                "\\\"Effect\\\":\\\"Allow\\\",\\r\\n         \\\"Action\\\":[\\r\\n             ");
                permissionPolicy.append("\\\"s3:GetObjectVersionForReplication\\\",\\r\\n            ");
                permissionPolicy.append(
                                "\\\"s3:GetObjectVersionAcl\\\"\\r\\n         ],\\r\\n         \\\"Resource\\\":[\\r\\n            ");
                permissionPolicy.append("\\\"arn:aws:s3:::");
                permissionPolicy.append(sourceBucket);
                permissionPolicy.append("/*\\\"\\r\\n         ]\\r\\n      },\\r\\n      {\\r\\n         ");
                permissionPolicy.append(
                                "\\\"Effect\\\":\\\"Allow\\\",\\r\\n         \\\"Action\\\":[\\r\\n            ");
                permissionPolicy.append(
                                "\\\"s3:ListBucket\\\",\\r\\n            \\\"s3:GetReplicationConfiguration\\\"\\r\\n         ");
                permissionPolicy.append("],\\r\\n         \\\"Resource\\\":[\\r\\n            \\\"arn:aws:s3:::");
                permissionPolicy.append(sourceBucket);
                permissionPolicy.append("\\r\\n         ");
                permissionPolicy
                                .append("]\\r\\n      },\\r\\n      {\\r\\n         \\\"Effect\\\":\\\"Allow\\\",\\r\\n         ");
                permissionPolicy.append(
                                "\\\"Action\\\":[\\r\\n            \\\"s3:ReplicateObject\\\",\\r\\n            ");
                permissionPolicy
                                .append("\\\"s3:ReplicateDelete\\\",\\r\\n            \\\"s3:ReplicateTags\\\",\\r\\n            ");
                permissionPolicy.append("\\\"s3:GetObjectVersionTagging\\\"\\r\\n\\r\\n         ],\\r\\n         ");
                permissionPolicy.append("\\\"Resource\\\":\\\"arn:aws:s3:::");
                permissionPolicy.append(destinationBucket);
                permissionPolicy.append("/*\\\"\\r\\n      }\\r\\n   ]\\r\\n}");

                PutRolePolicyRequest putRolePolicyRequest = new PutRolePolicyRequest()
                                .withRoleName(roleName)
                                .withPolicyDocument(permissionPolicy.toString())
                                .withPolicyName("crrRolePolicy");

                iamClient.putRolePolicy(putRolePolicyRequest);

        }
}

C#

Das folgende AWS SDK for .NET Codebeispiel fügt einem Bucket eine Replikationskonfiguration hinzu und ruft sie dann ab. Um diesen Code zu verwenden, geben Sie die Namen für die Buckets und den Amazon-Ressourcennamen (ARN) für die IAM-Rolle an. 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.Threading.Tasks;

namespace Amazon.DocSamples.S3
{
    class CrossRegionReplicationTest
    {
        private const string sourceBucket = "*** source bucket ***";
        // Bucket ARN example - arn:aws:s3:::destinationbucket
        private const string destinationBucketArn = "*** destination bucket ARN ***";
        private const string roleArn = "*** IAM Role ARN ***";
        // Specify your bucket region (an example region is shown).
        private static readonly RegionEndpoint sourceBucketRegion = RegionEndpoint.USWest2;
        private static IAmazonS3 s3Client;
        public static void Main()
        {
            s3Client = new AmazonS3Client(sourceBucketRegion);
            EnableReplicationAsync().Wait();
        }
        static async Task EnableReplicationAsync()
        {
            try
            {
                ReplicationConfiguration replConfig = new ReplicationConfiguration
                {
                    Role = roleArn,
                    Rules =
                        {
                            new ReplicationRule
                            {
                                Prefix = "Tax",
                                Status = ReplicationRuleStatus.Enabled,
                                Destination = new ReplicationDestination
                                {
                                    BucketArn = destinationBucketArn
                                }
                            }
                        }
                };

                PutBucketReplicationRequest putRequest = new PutBucketReplicationRequest
                {
                    BucketName = sourceBucket,
                    Configuration = replConfig
                };

                PutBucketReplicationResponse putResponse = await s3Client.PutBucketReplicationAsync(putRequest);

                // Verify configuration by retrieving it.
                await RetrieveReplicationConfigurationAsync(s3Client);
            }
            catch (AmazonS3Exception e)
            {
                Console.WriteLine("Error encountered on server. Message:'{0}' when writing an object", e.Message);
            }
            catch (Exception e)
            {
                Console.WriteLine("Unknown encountered on server. Message:'{0}' when writing an object", e.Message);
            }
        }
        private static async Task RetrieveReplicationConfigurationAsync(IAmazonS3 client)
        {
            // Retrieve the configuration.
            GetBucketReplicationRequest getRequest = new GetBucketReplicationRequest
            {
                BucketName = sourceBucket
            };
            GetBucketReplicationResponse getResponse = await client.GetBucketReplicationAsync(getRequest);
            // Print.
            Console.WriteLine("Printing replication configuration information...");
            Console.WriteLine("Role ARN: {0}", getResponse.Configuration.Role);
            foreach (var rule in getResponse.Configuration.Rules)
            {
                Console.WriteLine("ID: {0}", rule.Id);
                Console.WriteLine("Prefix: {0}", rule.Prefix);
                Console.WriteLine("Status: {0}", rule.Status);
            }
        }
    }
}

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

Beispiele für Replikation

Konfigurieren bei Buckets in verschiedenen Konten

Konfigurieren der Replikation für Quell- und Ziel-Buckets im Eigentum desselben Kontos

Anmerkung

Anmerkung

Anmerkung

Wichtig

Wichtig

Wichtig

Anmerkung

So richten Sie die Replikation ein, wenn sich Quell- und Ziel-Bucket im Besitz desselben befinden AWS-Konto

Wichtig

Anmerkung

Anmerkung