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-Verschlüsselungsclients (V1 auf V2)
**Anmerkung**
Wenn Sie V2 des S3-Verschlüsselungsclients verwenden und auf V3 migrieren möchten, finden Sie weitere Informationen unter[Migration des Amazon S3-Verschlüsselungsclients (V2 auf V3)](s3-encryption-migration-v2-v3.md).
In diesem Thema wird gezeigt, 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 für 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 AWS SDKs verwendet, müssen Sie jedes SDK separat aktualisieren.
2. **Migrieren Sie die 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. Im Folgenden finden Sie Einzelheiten zu jeder Hauptversion des AWS SDK für Ruby.
### Aktualisierung AWS SDK für Ruby, Version 3
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 für Projekte, die das `aws-sdk-s3` Gem installieren, die Versionsoption, um zu überprüfen, ob die Mindestversion von 1.76.0 installiert ist.
```
gem install aws-sdk-s3 -v '>= 1.76.0'
```
**Verwenden von Gemfiles **
Für Projekte, die ein Gemfile zur Verwaltung von Abhängigkeiten verwenden, setzen Sie die Mindestversion des `aws-sdk-s3` Gems auf 1.76.0. Beispiel:
```
gem 'aws-sdk-s3', '>= 1.76.0'
```
1. Modifizieren Sie Ihr Gemfile.
1. Führen Sie `bundle update aws-sdk-s3`. Führen Sie Folgendes aus, um Ihre Version zu überprüfen`bundle info aws-sdk-s3`.
### Upgrade AWS SDK für Ruby Version 2
Version 2 des AWS SDK für Ruby wird [ am 21. November 2021 in den ](https://aws.amazon.com/blogs/developer/deprecation-schedule-for-aws-sdk-for-ruby-v2/) Wartungsmodus versetzt. 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 für Projekte, 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'
```
**Verwenden von Gemfiles **
Für Projekte, die ein Gemfile zur Verwaltung von Abhängigkeiten verwenden, setzen Sie die Mindestversion des `aws-sdk` Gems auf 2.11.562. Beispiel:
```
gem 'aws-sdk', '>= 2.11.562'
```
1. Modifizieren 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 Folgendes 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 auf die neuen Verschlüsselungsformate aktualisiert haben, 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.
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 das gesamte Objekt bis zum Ende AES-GCM, bevor Sie die entschlüsselten Daten verwenden. Damit wird überprüft, ob das Objekt seit der Verschlüsselung nicht verändert wurde.
### Konfiguration von V2 Encryption Clients
Der * EncryptionV2: :Client * erfordert eine zusätzliche Konfiguration. Detaillierte Konfigurationsinformationen 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 Methode zum Umschließen von Schlüsseln und der Algorithmus zur Inhaltsverschlüsselung 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 es verwenden AWS KMS, muss dies auf gesetzt sein`:kms_context`. Wenn Sie einen symmetrischen Schlüssel (AES) verwenden, muss dieser auf `:aes_gcm` gesetzt sein. Wenn Sie einen asymmetrischen Schlüssel (RSA) verwenden, muss dieser auf gesetzt sein. `:rsa_oaep_sha1`
`content_encryption_schema`- Dieser muss auf:aes\_gcm\_no\_padding gesetzt sein. * *
2. **security\_profile muss bei der Erstellung des Clients angegeben werden. ** Wenn Sie ein neues erstellen`EncryptionV2::Client`, müssen Sie einen Wert für angeben`security_profile`. Der * Parameter * security\_profile bestimmt die Unterstützung für das Lesen von Objekten, die mit der älteren Version 1 geschrieben wurden. `Encryption::Client` Es gibt zwei Werte: :v2 * und:v2\_and\_legacy. * * * Um die Migration zu unterstützen, setzen Sie den Wert auf:v2\_and\_legacy. `security_profile` * * Verwenden Sie:v2 nur für die Entwicklung neuer Anwendungen*. *
3. **AWS KMS key Die ID wird standardmäßig durchgesetzt. ** In Version 1 wurde die zum Erstellen des Clients `kms_key_id` verwendete Datei nicht für den bereitgestellt AWS KMS `Decrypt call`. `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\_key\_id * 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, keinen bestimmten Wert festzulegen, wurde er entweder bei der Client-Erstellung oder bei Aufrufen festgelegt. `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)
**Pre-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)
```
**Post-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: Verwenden AWS KMS mit kms\_key\_id
**Pre-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)
```
**Post-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: Verwenden AWS KMS ohne kms\_key\_id
**Pre-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)
```
**Post-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
```
**Post-Migration Alternative **
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
```