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.
# Migration des Amazon S3 S3-Verschlüsselungsclients (V1 auf V2)
**Anmerkung**
Wenn Sie Version 2 des S3-Verschlüsselungsclients verwenden und zu Version 3 migrieren möchten, finden Sie weitere Informationen unter[Migration des Amazon S3 S3-Verschlüsselungsclients (V2 auf V3)](s3-encryption-migration-v2-v3.md).
In diesem Thema erfahren Sie, wie Sie Ihre Anwendungen von Version 1 (V1) des Amazon Simple Storage Service (Amazon S3) -Verschlüsselungsclients auf Version 2 (V2) migrieren und die Anwendungsverfügbarkeit während des gesamten Migrationsprozesses sicherstellen.
## Überblick über die Migration
Diese Migration erfolgt in zwei Phasen:
1. **Aktualisieren Sie bestehende Clients, damit sie neue Formate lesen können.** Stellen Sie zunächst eine aktualisierte Version des AWS SDK for Ruby in Ihrer Anwendung bereit. Dadurch können bestehende V1-Verschlüsselungsclients Objekte entschlüsseln, die von den neuen V2-Clients geschrieben wurden. Wenn Ihre Anwendung mehrere verwendet AWS SDKs, müssen Sie jedes SDK separat aktualisieren.
2. **Migrieren Sie Verschlüsselungs- und Entschlüsselungsclients auf V2.** Sobald alle Ihre V1-Verschlüsselungsclients neue Formate lesen können, können Sie Ihre vorhandenen Verschlüsselungs- und Entschlüsselungsclients auf ihre jeweiligen V2-Versionen migrieren.
## Aktualisieren Sie bestehende Clients, um neue Formate zu lesen
Der V2-Verschlüsselungsclient verwendet Verschlüsselungsalgorithmen, die ältere Versionen des Clients nicht unterstützen. Der erste Schritt der Migration besteht darin, Ihre V1-Entschlüsselungsclients auf die neueste SDK-Version zu aktualisieren. Nach Abschluss dieses Schritts können die V1-Clients Ihrer Anwendung Objekte entschlüsseln, die mit V2-Verschlüsselungsclients verschlüsselt wurden. Nachfolgend finden Sie Einzelheiten zu jeder Hauptversion des AWS SDK for Ruby.
### AWS SDK for Ruby Version 3 aktualisieren
Version 3 ist die neueste Version des AWS SDK für Ruby. Um diese Migration abzuschließen, müssen Sie Version 1.76.0 oder höher des `aws-sdk-s3` Gems verwenden.
**Installation über die Befehlszeile**
Verwenden Sie bei Projekten, die das `aws-sdk-s3` Gem installieren, die Versionsoption, um zu überprüfen, ob die Mindestversion 1.76.0 installiert ist.
```
gem install aws-sdk-s3 -v '>= 1.76.0'
```
**Gemfiles verwenden**
Für Projekte, die ein Gemfile zur Verwaltung von Abhängigkeiten verwenden, legen Sie die Mindestversion des `aws-sdk-s3` Gems auf 1.76.0 fest. Beispiel:
```
gem 'aws-sdk-s3', '>= 1.76.0'
```
1. Ändern Sie Ihr Gemfile.
1. Führen Sie `bundle update aws-sdk-s3`. Führen `bundle info aws-sdk-s3` Sie den Befehl aus, um Ihre Version zu überprüfen.
### AWS SDK for Ruby Version 2 aktualisieren
Version 2 des AWS SDK for Ruby wird am 21. November 2021 in den [Wartungsmodus wechseln](https://aws.amazon.com/blogs/developer/deprecation-schedule-for-aws-sdk-for-ruby-v2/). Um diese Migration abzuschließen, müssen Sie Version 2.11.562 oder höher des aws-sdk-Gems verwenden.
**Installation über die Befehlszeile**
Verwenden Sie bei Projekten, die das `aws-sdk` Gem über die Befehlszeile installieren, die Versionsoption, um zu überprüfen, ob die Mindestversion von 2.11.562 installiert ist.
```
gem install aws-sdk -v '>= 2.11.562'
```
**Gemfiles verwenden**
Für Projekte, die ein Gemfile zur Verwaltung von Abhängigkeiten verwenden, legen Sie die Mindestversion des `aws-sdk` Gems auf 2.11.562 fest. Beispiel:
```
gem 'aws-sdk', '>= 2.11.562'
```
1. Ändern Sie Ihr Gemfile. Wenn Sie eine Gemfile.lock-Datei haben, löschen oder aktualisieren Sie sie.
1. Führen Sie `bundle update aws-sdk`. Führen Sie den Befehl aus, um Ihre Version zu überprüfen. `bundle info aws-sdk`
## Migrieren Sie die Verschlüsselungs- und Entschlüsselungsclients auf V2
Nachdem Sie Ihre Clients so aktualisiert haben, dass sie die neuen Verschlüsselungsformate lesen können, können Sie Ihre Anwendungen auf die V2-Verschlüsselungs- und Entschlüsselungsclients aktualisieren. Die folgenden Schritte zeigen Ihnen, wie Sie Ihren Code erfolgreich von V1 auf V2 migrieren können.
Bevor Sie Ihren Code für die Verwendung des V2-Verschlüsselungsclients aktualisieren, stellen Sie sicher, dass Sie die vorherigen Schritte befolgt haben und die `aws-sdk-s3` Gem-Version 2.11.562 oder höher verwenden.
**Anmerkung**
Lesen Sie beim Entschlüsseln mit AES-GCM das gesamte Objekt bis zum Ende, bevor Sie die entschlüsselten Daten verwenden. Dadurch wird überprüft, ob das Objekt seit der Verschlüsselung nicht geändert wurde.
### Konfiguration von V2-Verschlüsselungsclients
Der *EncryptionV2: :Client erfordert eine zusätzliche Konfiguration*. Ausführliche Informationen zur Konfiguration finden Sie in der [EncryptionV2: :Client-Dokumentation](https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/S3/EncryptionV2/Client.html#initialize-instance_method) oder in den Beispielen weiter unten in diesem Thema.
1. **Die Key-Wrap-Methode und der Inhaltsverschlüsselungsalgorithmus müssen bei der Client-Erstellung angegeben werden.** Wenn Sie ein neues erstellen`EncryptionV2::Client`, müssen Sie Werte für `key_wrap_schema` und angeben`content_encryption_schema`.
`key_wrap_schema`- Wenn Sie verwenden AWS KMS, muss dies auf eingestellt sein`:kms_context`. Wenn Sie einen symmetrischen Schlüssel (AES) verwenden, muss dieser auf `:aes_gcm` eingestellt sein. Wenn Sie einen asymmetrischen Schlüssel (RSA) verwenden, muss dieser auf eingestellt sein. `:rsa_oaep_sha1`
`content_encryption_schema`*- Dieser Wert muss auf:aes\$1gcm\$1no\$1padding gesetzt sein.*
2. **security\$1profile muss bei der Client-Erstellung angegeben werden.** Wenn Sie ein neues erstellen`EncryptionV2::Client`, müssen Sie einen Wert für angeben. `security_profile` Der Parameter *security\$1profile* bestimmt die Unterstützung für das Lesen von Objekten, die mit der älteren Version V1 geschrieben wurden. `Encryption::Client` **Es gibt zwei Werte ::v2 und:v2\$1and\$1legacy.** *Um die Migration zu unterstützen, setzen Sie den Wert to:v2\$1and\$1legacy. `security_profile`* *Verwenden Sie:v2 nur für die Entwicklung neuer Anwendungen.*
3. **AWS KMS key ID wird standardmäßig erzwungen.** In Version 1 wurde die `kms_key_id` zur Erstellung des Clients verwendete Datei nicht an die AWS KMS `Decrypt call` weitergegeben. `Encryption::Client` AWS KMS kann diese Informationen aus Metadaten abrufen und sie dem symmetrischen Chiffretext-Blob hinzufügen. In V2, e`NCryptionV2: :Client`, wird die *kms\$1key\$1id* an den Decrypt-Aufruf übergeben, und der Aufruf schlägt fehl, wenn sie nicht mit dem Schlüssel übereinstimmt, der zum AWS KMS Verschlüsseln des Objekts verwendet wurde. Wenn Ihr Code zuvor darauf beruhte, dass kein bestimmtes festgelegt wurde, dann entweder bei der Client-Erstellung oder bei Aufrufen. `kms_key_id` `kms_key_id: :kms_allow_decrypt_with_any_cmk` `kms_allow_decrypt_with_any_cmk: true` `get_object`
### Beispiel: Verwendung eines symmetrischen Schlüssels (AES)
**Vor der Migration**
```
client = Aws::S3::Encryption::Client.new(encryption_key: aes_key)
client.put_object(bucket: bucket, key: key, body: secret_data)
resp = client.get_object(bucket: bucket, key: key)
```
**Nach der Migration**
```
client = Aws::S3::EncryptionV2::Client.new(
encryption_key: rsa_key,
key_wrap_schema: :rsa_oaep_sha1, # the key_wrap_schema must be rsa_oaep_sha1 for asymmetric keys
content_encryption_schema: :aes_gcm_no_padding,
security_profile: :v2_and_legacy # to allow reading/decrypting objects encrypted by the V1 encryption client
)
client.put_object(bucket: bucket, key: key, body: secret_data) # No changes
resp = client.get_object(bucket: bucket, key: key) # No changes
```
### Beispiel: Verwendung AWS KMS mit kms\$1key\$1id
**Vor der Migration**
```
client = Aws::S3::Encryption::Client.new(kms_key_id: kms_key_id)
client.put_object(bucket: bucket, key: key, body: secret_data)
resp = client.get_object(bucket: bucket, key: key)
```
**Nach der Migration**
```
client = Aws::S3::EncryptionV2::Client.new(
kms_key_id: kms_key_id,
key_wrap_schema: :kms_context, # the key_wrap_schema must be kms_context for KMS keys
content_encryption_schema: :aes_gcm_no_padding,
security_profile: :v2_and_legacy # to allow reading/decrypting objects encrypted by the V1 encryption client
)
client.put_object(bucket: bucket, key: key, body: secret_data) # No changes
resp = client.get_object(bucket: bucket, key: key) # No change
```
### Beispiel: Verwendung AWS KMS ohne kms\$1key\$1id
**Vor der Migration**
```
client = Aws::S3::Encryption::Client.new(kms_key_id: kms_key_id)
client.put_object(bucket: bucket, key: key, body: secret_data)
resp = client.get_object(bucket: bucket, key: key)
```
**Nach der Migration**
```
client = Aws::S3::EncryptionV2::Client.new(
kms_key_id: kms_key_id,
key_wrap_schema: :kms_context, # the key_wrap_schema must be kms_context for KMS keys
content_encryption_schema: :aes_gcm_no_padding,
security_profile: :v2_and_legacy # to allow reading/decrypting objects encrypted by the V1 encryption client
)
client.put_object(bucket: bucket, key: key, body: secret_data) # No changes
resp = client.get_object(bucket: bucket, key: key, kms_allow_decrypt_with_any_cmk: true) # To allow decrypting with any cmk
```
**Alternative nach der Migration**
Wenn Sie Objekte nur mit dem S2-Verschlüsselungsclient lesen und entschlüsseln (niemals schreiben und verschlüsseln), verwenden Sie diesen Code.
```
client = Aws::S3::EncryptionV2::Client.new(
kms_key_id: :kms_allow_decrypt_with_any_cmk, # set kms_key_id to allow all get_object requests to use any cmk
key_wrap_schema: :kms_context, # the key_wrap_schema must be kms_context for KMS keys
content_encryption_schema: :aes_gcm_no_padding,
security_profile: :v2_and_legacy # to allow reading/decrypting objects encrypted by the V1 encryption client
)
resp = client.get_object(bucket: bucket, key: key) # No change
```