Amazon S3 マネージドキーによるサーバー側の暗号化 (SSE-S3) の指定 - Amazon Simple Storage Service

Amazon S3 マネージドキーによるサーバー側の暗号化 (SSE-S3) の指定

重要

Amazon S3 では、Amazon S3 内のすべてのバケットの基本レベルの暗号化として、Amazon S3 が管理するキー (SSE-S3) によるサーバー側の暗号化が適用されるようになりました。2023 年 1 月 5 日以降、Amazon S3 にアップロードされるすべての新しいオブジェクトは、追加費用なしで、パフォーマンスに影響を与えずに自動的に暗号化されます。S3 バケットのデフォルト暗号化設定と新しいオブジェクトのアップロードのための自動暗号化ステータスは、AWS CloudTrail ログ、S3 インベントリ、S3 ストレージレンズ、Amazon S3 コンソール、および AWS Command Line Interface と AWS SDK の追加の Amazon S3 API レスポンスヘッダーとして利用できるようになりました。詳細については、「デフォルト暗号化に関するよくある質問」を参照してください。

すべての Amazon S3 バケットにはデフォルトで暗号化が設定されており、S3 バケットにアップロードされたすべての新しいオブジェクトは保存時に自動的に暗号化されます。Amazon S3 マネージドキーによるサーバー側の暗号化 (SSE-S3) は、Amazon S3 のすべてのバケットでのデフォルトの暗号化設定です。別のタイプの暗号化を使用するには、S3 PUT リクエストで使用するサーバー側の暗号化のタイプを指定するか、宛先バケットにデフォルトの暗号化設定を設定できます。

PUT リクエストで別の暗号化タイプを指定する場合は、AWS Key Management Service (AWS KMS) キーによるサーバー側の暗号化 (SSE-KMS)、AWS KMS キーによる二層式サーバー側の暗号化 (DSSE-KMS)、または顧客提供のキーによるサーバー側の暗号化 (SSE-C) を使用できます。宛先バケットに別のデフォルト暗号化設定を設定する場合は、SSE-KMS または DSSE-KMS を使用できます。

S3 コンソール、REST API、AWS SDK、および AWS Command Line Interface (AWS CLI) を使用して SSE−S3 を指定できます。詳細については、「Amazon S3 バケット向けのサーバー側のデフォルトの暗号化動作の設定」を参照してください。

このトピックでは、AWS Management Console を使用してオブジェクトの暗号化のタイプを設定または変更する方法について説明します。コンソールを使用してオブジェクトをコピーする場合、Amazon S3 はオブジェクトを現状のままコピーします。つまり、ソースが暗号化されている場合、ターゲットオブジェクトも暗号化されます。コンソールを使用して、オブジェクトの暗号化を追加または変更することもできます。

注記

  • オブジェクトの暗号化を変更すると、新しいオブジェクトが作成され、古いオブジェクトが置き換えられます。S3 バージョニングが有効になっている場合は、オブジェクトの新しいバージョンが作成され、既存のオブジェクトが古いバージョンになります。また、プロパティを変更するロールは、新しいオブジェクト (またはオブジェクトのバージョン) の所有者になります。

  • ユーザー定義タグを持つオブジェクトの暗号化タイプを変更する場合は、s3:GetObjectTagging アクセス許可が必要です。ユーザー定義タグがなく、サイズが 16 MB を超えるオブジェクトの暗号化タイプを変更する場合は、s3:GetObjectTagging アクセス許可も必要です。

    ターゲットバケットポリシーによって s3:GetObjectTagging アクションが拒否されると、オブジェクトの暗号化タイプは更新されますが、ユーザー定義タグはオブジェクトから削除され、エラーが発生します。

オブジェクトの暗号化を変更するには

  1. AWS Management Console にサインインし、Amazon S3 コンソール (https://console.aws.amazon.com/s3/) を開きます。

  2. 左側のナビゲーションペインで、[バケット] を選択します。

  3. [Buckets] (バケット) リストで、オブジェクトが含まれるバケットの名前を選択します。

  4. [オブジェクト] リストで、暗号化を追加または変更するオブジェクトの名前を選択します。

    オブジェクトの詳細ページが開き、オブジェクトのプロパティを表示するいくつかのセクションが表示されます。

  5. [プロパティ] タブを選択します。

  6. 「サーバー側の暗号化設定」セクションまでスクロールし、[編集] を選択します。

  7. [暗号化設定] で、[バケットのデフォルトの暗号化設定を使用する] または [バケットのデフォルトの暗号化設定を上書きする] を選択します。

  8. [デフォルトの暗号化にバケット設定を上書きする] を選択した場合は、次の暗号化設定を設定します。

    1. [暗号化タイプ] で、[Amazon S3 マネージドキー (SSE-S3)] を選択します。SSE-S3 は、最強のブロック暗号の 1 つである 256 ビットの 高度暗号化規格 (AES-256) を使用して、各オブジェクトを暗号化します。詳細については、「Amazon S3 マネージドキーによるサーバー側の暗号化 (SSE-S3)」を参照してください。

  9. [Save changes] (変更の保存) をクリックします。

注記

このアクションは、指定されたすべてのオブジェクトに暗号化を適用します。フォルダを暗号化する場合は、保存オペレーションが完了するのを待ってから、フォルダに新しいオブジェクトを追加します。

オブジェクト作成時、つまり、新しいオブジェクトをアップロードするときや既存オブジェクトのコピーを作成するときに、リクエストに x-amz-server-side-encryption ヘッダーを追加することで、Amazon S3 マネージドキー (SSE-S3) を使用してデータを暗号化するかどうかを指定することができます。ヘッダーの値を、Amazon S3 がサポートする暗号化アルゴリズム AES256 に設定します。Amazon S3 によりレスポンスヘッダー x-amz-server-side-encryption が返されるため、SSE-S3 を使用してオブジェクトが保存されたことを確認できます。

次の REST アップロード API オペレーションは、x-amz-server-side-encryption リクエストヘッダーを受け付けます。

マルチパートアップロード API オペレーションを使用して大容量のオブジェクトをアップロードするときに、x-amz-server-side-encryption ヘッダーを Initiate Multipart Upload リクエストに追加することでサーバー側の暗号化を指定することができます。既存のオブジェクトをコピーする際は、コピー元オブジェクトが暗号化されているかどうかに関係なく、明示的にサーバー側の暗号化を要求しない限り、コピー先オブジェクトは暗号化されません。

次の REST API オペレーションのレスポンスヘッダーは、オブジェクトが SSE-S3 を使用して保存されているときに x-amz-server-side-encryption ヘッダーを返します。

注記

オブジェクトで SSE−S3 を使用している場合、または、HTTP ステータスコード 400 (BadRequest) エラーが発生する場合、暗号化リクエストヘッダーを GET リクエストおよび HEAD リクエストに対して送信しないでください。

AWS SDK を使用して、Amazon S3 マネージド暗号化キー (SSE-S3) を使用するように Amazon S3 にリクエストできます。このセクションでは、AWS SDK を複数の言語で使用する場合の例を示します。他の SDK については、「サンプルコードとライブラリ」を参照してください。

Java

AWS SDK for Java を使用してオブジェクトをアップロードしたら、SSE-S3 を使用してデータを暗号化します。サーバー側の暗号化を要求するには、ObjectMetadata の PutObjectRequest プロパティを使用して x-amz-server-side-encryption リクエストヘッダーを設定します。AmazonS3Client の putObject() メソッドを呼び出すと、Amazon S3 はデータを暗号化して保存します。

さらに、マルチパートアップロード API オペレーションを使用して、オブジェクトのアップロード時に、SSE-S3 暗号化をリクエストすることもできます。

  • 高レベルマルチパートアップロード API オペレーションを使用するときに、TransferManager メソッドを使用して、アップロード時にサーバー側の暗号化をオブジェクトに適用できます。パラメータとして ObjectMetadata を受け取る、どのアップロードメソッドを使用してもかまいません。詳細については、「マルチパートアップロードを使用したオブジェクトのアップロード」を参照してください。

  • 低レベルマルチパートアップロード API オペレーションを使用する場合は、マルチパートアップロードの開始時にサーバー側の暗号化を指定します。ObjectMetadata メソッドを呼び出して InitiateMultipartUploadRequest.setObjectMetadata() プロパティを追加します。詳細については、AWS SDK の使用 (低レベル API) を参照してください。

オブジェクトの暗号化状態を直接変更することはできません (暗号化されていないオブジェクトの暗号化、または暗号化されたオブジェクトの復号)。オブジェクトの暗号化状態を変更するには、オブジェクトのコピーを作成し、コピーの目的の暗号化状態を指定してから、元のオブジェクトを削除します。Amazon S3 は、明示的にサーバー側の暗号化を要求した場合にのみ、コピーされたオブジェクトを暗号化します。Java API を通じて、コピーされたオブジェクトの暗号化を要求するには、ObjectMetadata プロパティを使用して、CopyObjectRequest でサーバー側の暗号化を指定します。

例

次の例は、AWS SDK for Java を使用してサーバー側の暗号化を設定する方法を示しています。ここでは、以下のタスクの実行方法について説明します。

  • SSE-S3 を使用して新しいオブジェクトをアップロードします。

  • オブジェクトのコピーを作成して、オブジェクトの暗号化状態を変更する (この例では、以前に暗号化されていないオブジェクトを暗号化する)

  • オブジェクトの暗号化状態を確認する

サーバーサイドの暗号化の詳細については、「REST API の使用」を参照してください。作業サンプルの作成およびテストの手順については、「AWS SDK for Java のデベロッパーガイド」の「使用開始」を参照してください。


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.internal.SSEResultBase;
import com.amazonaws.services.s3.model.*;

import java.io.ByteArrayInputStream;

public class SpecifyServerSideEncryption {

    public static void main(String[] args) {
        Regions clientRegion = Regions.DEFAULT_REGION;
        String bucketName = "*** Bucket name ***";
        String keyNameToEncrypt = "*** Key name for an object to upload and encrypt ***";
        String keyNameToCopyAndEncrypt = "*** Key name for an unencrypted object to be encrypted by copying ***";
        String copiedObjectKeyName = "*** Key name for the encrypted copy of the unencrypted object ***";

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

            // Upload an object and encrypt it with SSE.
            uploadObjectWithSSEEncryption(s3Client, bucketName, keyNameToEncrypt);

            // Upload a new unencrypted object, then change its encryption state
            // to encrypted by making a copy.
            changeSSEEncryptionStatusByCopying(s3Client,
                    bucketName,
                    keyNameToCopyAndEncrypt,
                    copiedObjectKeyName);
        } 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 uploadObjectWithSSEEncryption(AmazonS3 s3Client, String bucketName, String keyName) {
        String objectContent = "Test object encrypted with SSE";
        byte[] objectBytes = objectContent.getBytes();

        // Specify server-side encryption.
        ObjectMetadata objectMetadata = new ObjectMetadata();
        objectMetadata.setContentLength(objectBytes.length);
        objectMetadata.setSSEAlgorithm(ObjectMetadata.AES_256_SERVER_SIDE_ENCRYPTION);
        PutObjectRequest putRequest = new PutObjectRequest(bucketName,
                keyName,
                new ByteArrayInputStream(objectBytes),
                objectMetadata);

        // Upload the object and check its encryption status.
        PutObjectResult putResult = s3Client.putObject(putRequest);
        System.out.println("Object \"" + keyName + "\" uploaded with SSE.");
        printEncryptionStatus(putResult);
    }

    private static void changeSSEEncryptionStatusByCopying(AmazonS3 s3Client,
            String bucketName,
            String sourceKey,
            String destKey) {
        // Upload a new, unencrypted object.
        PutObjectResult putResult = s3Client.putObject(bucketName, sourceKey, "Object example to encrypt by copying");
        System.out.println("Unencrypted object \"" + sourceKey + "\" uploaded.");
        printEncryptionStatus(putResult);

        // Make a copy of the object and use server-side encryption when storing the
        // copy.
        CopyObjectRequest request = new CopyObjectRequest(bucketName,
                sourceKey,
                bucketName,
                destKey);
        ObjectMetadata objectMetadata = new ObjectMetadata();
        objectMetadata.setSSEAlgorithm(ObjectMetadata.AES_256_SERVER_SIDE_ENCRYPTION);
        request.setNewObjectMetadata(objectMetadata);

        // Perform the copy operation and display the copy's encryption status.
        CopyObjectResult response = s3Client.copyObject(request);
        System.out.println("Object \"" + destKey + "\" uploaded with SSE.");
        printEncryptionStatus(response);

        // Delete the original, unencrypted object, leaving only the encrypted copy in
        // Amazon S3.
        s3Client.deleteObject(bucketName, sourceKey);
        System.out.println("Unencrypted object \"" + sourceKey + "\" deleted.");
    }

    private static void printEncryptionStatus(SSEResultBase response) {
        String encryptionStatus = response.getSSEAlgorithm();
        if (encryptionStatus == null) {
            encryptionStatus = "Not encrypted with SSE";
        }
        System.out.println("Object encryption status is: " + encryptionStatus);
    }
}
.NET

オブジェクトをアップロードするときに、それを暗号化するように Amazon S3 に指定できます。既存のオブジェクトの暗号化状態を変更するには、オブジェクトのコピーを作成し、コピー元オブジェクトを削除します。デフォルトでは、ターゲットオブジェクトのサーバー側の暗号化を明示的に要求した場合、コピーオペレーションではターゲットのみが暗号化されます。CopyObjectRequest で SSE-S3 を指定するには、以下を追加します。

 ServerSideEncryptionMethod = ServerSideEncryptionMethod.AES256

オブジェクトのコピー方法を示す作業サンプルについては、AWS SDK の使用 を参照してください。

次の例では、オブジェクトをアップロードします。このリクエストでは、オブジェクトを暗号化するように Amazon S3 に指定します。次に、オブジェクトのメタデータを取得し、使用された暗号化方法を確認します。コード例を設定および実行する方法の詳細については、「AWS SDK for .NET デベロッパーガイド」の「AWS SDK for .NET の開始方法」 を参照してください。

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

namespace Amazon.DocSamples.S3
{
    class SpecifyServerSideEncryptionTest
    {
        private const string bucketName = "*** bucket name ***";
        private const string keyName = "*** key name for object created ***";
        // 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);
            WritingAnObjectAsync().Wait();
        }

        static async Task WritingAnObjectAsync()
        {
            try
            {
                var putRequest = new PutObjectRequest
                {
                    BucketName = bucketName,
                    Key = keyName,
                    ContentBody = "sample text",
                    ServerSideEncryptionMethod = ServerSideEncryptionMethod.AES256
                };

                var putResponse = await client.PutObjectAsync(putRequest);

                // Determine the encryption state of an object.
                GetObjectMetadataRequest metadataRequest = new GetObjectMetadataRequest
                {
                    BucketName = bucketName,
                    Key = keyName
                };
                GetObjectMetadataResponse response = await client.GetObjectMetadataAsync(metadataRequest);
                ServerSideEncryptionMethod objectEncryption = response.ServerSideEncryptionMethod;

                Console.WriteLine("Encryption method used: {0}", objectEncryption.ToString());
            }
            catch (AmazonS3Exception e)
            {
                Console.WriteLine("Error encountered ***. 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);
            }
        }
    }
}
PHP

このトピックでは、バージョン 3 の AWS SDK for PHP のクラスを使用して、Amazon S3 にアップロードするオブジェクトに SSE-S3 を追加する方法を示します。AWS SDK for Ruby API の詳細については、AWS SDK for Ruby - バージョン 2 を参照してください。

オブジェクトを Amazon S3 にアップロードするには、Aws\S3\S3Client::putObject() メソッドを使用します。アップロードリクエストに x-amz-server-side-encryption リクエストヘッダーを追加するには、ServerSideEncryption パラメータを指定して AES256 値を設定します。以下に例を示します。サーバー側の暗号化のリクエストについては、REST API の使用 を参照してください。

 require 'vendor/autoload.php';

use Aws\S3\S3Client;

$bucket = '*** Your Bucket Name ***';
$keyname = '*** Your Object Key ***';

// $filepath should be an absolute path to a file on disk.
$filepath = '*** Your File Path ***';

$s3 = new S3Client([
    'version' => 'latest',
    'region'  => 'us-east-1'
]);

// Upload a file with server-side encryption.
$result = $s3->putObject([
    'Bucket'               => $bucket,
    'Key'                  => $keyname,
    'SourceFile'           => $filepath,
    'ServerSideEncryption' => 'AES256',
]);

レスポンスとして、Amazon S3 は、x-amz-server-side-encryption ヘッダーを返します。このヘッダーには、オブジェクトのデータの暗号化に使用された暗号化アルゴリズムの値が設定されています。

マルチパートアップロード API オペレーションを使用して大容量のオブジェクトをアップロードする場合、以下のように、アップロードするオブジェクトに対して SSE-S3 を指定できます。

  • 低レベルのマルチパートアップロード API オペレーションを使用する場合は、Aws\S3\S3Client::createMultipartUpload() メソッドを呼び出すときにサーバー側の暗号化を指定します。リクエストに x-amz-server-side-encryption ヘッダーを追加する場合は、値 array を使用して ServerSideEncryption パラメータの AES256 キーを指定します。低レベルのマルチパートアップロード API オペレーションの詳細については、「AWS SDK の使用 (低レベル API)」を参照してください。

  • 高レベルのマルチパートアップロード API オペレーションを使用する場合は、CreateMultipartUpload API オペレーションの ServerSideEncryption パラメータを使用してサーバー側の暗号化を指定します。高レベルのマルチパートアップロード API オペレーションで setOption() メソッドを使用する例については、「マルチパートアップロードを使用したオブジェクトのアップロード」を参照してください。

以下の PHP コード例に示すように、Aws\S3\S3Client::headObject() メソッドを呼び出し、オブジェクトメタデータを取得して、既存のオブジェクトの暗号化状態を確認できます。

 require 'vendor/autoload.php';

use Aws\S3\S3Client;

$bucket = '*** Your Bucket Name ***';
$keyname = '*** Your Object Key ***';

$s3 = new S3Client([
    'version' => 'latest',
    'region'  => 'us-east-1'
]);

// Check which server-side encryption algorithm is used.
$result = $s3->headObject([
    'Bucket' => $bucket,
    'Key'    => $keyname,
]);
echo $result['ServerSideEncryption'];

Aws\S3\S3Client::copyObject() メソッドを使用してオブジェクトのコピーを作成し、コピー元のオブジェクトを削除することで、既存のオブジェクトの暗号化状態を変更できます。デフォルトでは、copyObject() によってコピー先は暗号化されません。ただし、ServerSideEncryption パラメータで AES256 値を使用して、コピー先オブジェクトに対するサーバー側の暗号化を明示的にリクエストした場合は除きます。以下の PHP コード例では、オブジェクトのコピーを作成し、コピー先のオブジェクトにサーバー側の暗号化を追加しています。

 require 'vendor/autoload.php';

use Aws\S3\S3Client;

$sourceBucket = '*** Your Source Bucket Name ***';
$sourceKeyname = '*** Your Source Object Key ***';

$targetBucket = '*** Your Target Bucket Name ***';
$targetKeyname = '*** Your Target Object Key ***';

$s3 = new S3Client([
    'version' => 'latest',
    'region'  => 'us-east-1'
]);

// Copy an object and add server-side encryption.
$s3->copyObject([
    'Bucket'               => $targetBucket,
    'Key'                  => $targetKeyname,
    'CopySource'           => "$sourceBucket/$sourceKeyname",
    'ServerSideEncryption' => 'AES256',
]);

詳細については、以下の各トピックを参照してください。

Ruby

AWS SDK for Ruby を使用してオブジェクトをアップロードするときは、SSE-S3 により保管時にオブジェクトを暗号化して保存することを指定できます。オブジェクトは、読み戻すときに自動的に復号されます。

次の AWS SDK for Ruby バージョン 3 のサンプルは、Amazon S3 にアップロードするファイルを保管時に暗号化するよう指定する方法を示しています。

require 'aws-sdk-s3'

# Wraps Amazon S3 object actions.
class ObjectPutSseWrapper
  attr_reader :object

  # @param object [Aws::S3::Object] An existing Amazon S3 object.
  def initialize(object)
    @object = object
  end

  def put_object_encrypted(object_content, encryption)
    @object.put(body: object_content, server_side_encryption: encryption)
    true
  rescue Aws::Errors::ServiceError => e
    puts "Couldn't put your content to #{object.key}. Here's why: #{e.message}"
    false
  end
end

# Example usage:
def run_demo
<<<<<<< HEAD
  bucket_name = "amzn-s3-demo-bucket"
  object_key = "my-encrypted-content"
  object_content = "This is my super-secret content."
  encryption = "AES256"
=======
  bucket_name = 'doc-example-bucket'
  object_key = 'my-encrypted-content'
  object_content = 'This is my super-secret content.'
  encryption = 'AES256'
>>>>>>> 999c6133e (fixes)

  wrapper = ObjectPutSseWrapper.new(Aws::S3::Object.new(bucket_name, object_content))
  return unless wrapper.put_object_encrypted(object_content, encryption)

  puts "Put your content into #{bucket_name}:#{object_key} and encrypted it with #{encryption}."
end

run_demo if $PROGRAM_NAME == __FILE__

次のコード例は、既存のオブジェクトの暗号化状態を判定する方法を示しています。

require 'aws-sdk-s3'

# Wraps Amazon S3 object actions.
class ObjectGetEncryptionWrapper
  attr_reader :object

  # @param object [Aws::S3::Object] An existing Amazon S3 object.
  def initialize(object)
    @object = object
  end

  # Gets the object into memory.
  #
  # @return [Aws::S3::Types::GetObjectOutput, nil] The retrieved object data if successful; otherwise nil.
  def object
    @object.get
  rescue Aws::Errors::ServiceError => e
    puts "Couldn't get object #{@object.key}. Here's why: #{e.message}"
  end
end

# Example usage:
def run_demo
<<<<<<< HEAD
  bucket_name = "amzn-s3-demo-bucket"
  object_key = "my-object.txt"
=======
  bucket_name = 'doc-example-bucket'
  object_key = 'my-object.txt'
>>>>>>> 999c6133e (fixes)

  wrapper = ObjectGetEncryptionWrapper.new(Aws::S3::Object.new(bucket_name, object_key))
  obj_data = wrapper.get_object
  return unless obj_data

  encryption = obj_data.server_side_encryption.nil? ? 'no' : obj_data.server_side_encryption
  puts "Object #{object_key} uses #{encryption} encryption."
end

run_demo if $PROGRAM_NAME == __FILE__

Amazon S3 に保存されたオブジェクトにサーバー側の暗号化が使用されていない場合、メソッドは null を返します。

既存のオブジェクトの暗号化状態を変更するには、オブジェクトのコピーを作成し、コピー元オブジェクトを削除します。デフォルトでは、明示的にサーバー側の暗号化を要求しない限り、コピーメソッドはターゲットを暗号化しません。ターゲットオブジェクトの暗号化を要求するには、次の Ruby コードの例に示すように、オプションのハッシュ引数に server_side_encryption 値を指定します。このコード例は、オブジェクトをコピーし、コピーを SSE-S3 で暗号化する方法を示しています。

require 'aws-sdk-s3'

# Wraps Amazon S3 object actions.
class ObjectCopyEncryptWrapper
  attr_reader :source_object

  # @param source_object [Aws::S3::Object] An existing Amazon S3 object. This is used as the source object for
  #                                        copy actions.
  def initialize(source_object)
    @source_object = source_object
  end

  # Copy the source object to the specified target bucket, rename it with the target key, and encrypt it.
  #
  # @param target_bucket [Aws::S3::Bucket] An existing Amazon S3 bucket where the object is copied.
  # @param target_object_key [String] The key to give the copy of the object.
  # @return [Aws::S3::Object, nil] The copied object when successful; otherwise, nil.
  def copy_object(target_bucket, target_object_key, encryption)
    @source_object.copy_to(bucket: target_bucket.name, key: target_object_key, server_side_encryption: encryption)
    target_bucket.object(target_object_key)
  rescue Aws::Errors::ServiceError => e
    puts "Couldn't copy #{@source_object.key} to #{target_object_key}. Here's why: #{e.message}"
  end
end

# Example usage:
def run_demo
<<<<<<< HEAD
  source_bucket_name = "amzn-s3-demo-bucket1"
  source_key = "my-source-file.txt"
  target_bucket_name = "amzn-s3-demo-bucket2"
  target_key = "my-target-file.txt"
  target_encryption = "AES256"
=======
  source_bucket_name = 'doc-example-bucket1'
  source_key = 'my-source-file.txt'
  target_bucket_name = 'doc-example-bucket2'
  target_key = 'my-target-file.txt'
  target_encryption = 'AES256'
>>>>>>> 999c6133e (fixes)

  source_bucket = Aws::S3::Bucket.new(source_bucket_name)
  wrapper = ObjectCopyEncryptWrapper.new(source_bucket.object(source_key))
  target_bucket = Aws::S3::Bucket.new(target_bucket_name)
  target_object = wrapper.copy_object(target_bucket, target_key, target_encryption)
  return unless target_object

  puts "Copied #{source_key} from #{source_bucket_name} to #{target_object.bucket_name}:#{target_object.key} and "\
       "encrypted the target with #{target_object.server_side_encryption} encryption."
end

run_demo if $PROGRAM_NAME == __FILE__

AWS CLI を使用してオブジェクトをアップロードするときに SSE−S3 を指定するには、次の例を使用します。

aws s3api put-object --bucket amzn-s3-demo-bucket1 --key object-key-name --server-side-encryption AES256  --body file path

詳細については、AWS CLI リファレンスの put−object を参照してください。AWS CLI を使用してオブジェクトをコピーするときに SSE−S3 を指定するには、copy−object を参照してください。

AWS CloudFormation を使用して暗号化を設定する例については、AWS CloudFormation ユーザーガイドの AWS::S3::Bucket ServerSideEncryptionRule トピックの「デフォルト暗号化を備えたバケットの作成」および「AWS KMS サーバー側の暗号化と S3 バケットキーを使用したバケットの作成」の例を参照してください。