Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Menggunakan enkripsi di sisi server dengan kunci terkelola Amazon S3 (SSE-S3)
**penting**
Amazon S3 sudah menerapkan enkripsi di sisi server dengan kunci terkelola Amazon S3 (SSE-S3) sebagai tingkat dasar enkripsi bagi setiap bucket di Amazon S3. Mulai 5 Januari 2023, semua unggahan objek baru ke Amazon S3 secara otomatis akan dienkripsi tanpa biaya tambahan dan tidak akan berdampak pada kinerja. Status enkripsi otomatis untuk konfigurasi enkripsi default bucket S3 dan untuk unggahan objek baru tersedia di CloudTrail log, S3 Inventory, S3 Storage Lens, konsol Amazon S3, dan sebagai header respons API Amazon S3 tambahan di dan. AWS CLI AWS SDKs Untuk informasi selengkapnya, lihat [FAQ enkripsi default](https://docs.aws.amazon.com/AmazonS3/latest/userguide/default-encryption-faq.html).
Semua unggahan objek baru ke bucket Amazon S3 dienkripsi secara default dengan enkripsi di sisi server dengan kunci terkelola Amazon S3 (SSE-S3).
Enkripsi sisi-server melindungi data diam. Amazon S3 mengenkripsi setiap objek dengan kunci unik. Sebagai perlindungan tambahan, ia mengenkripsi kunci itu sendiri dengan kunci yang diputar secara berkala. Enkripsi sisi server Amazon S3 menggunakan Galois/Counter Mode Standar Enkripsi Lanjutan (AES-GCM) 256-bit untuk mengenkripsi semua objek yang diunggah.
Tidak ada biaya tambahan untuk menggunakan enkripsi di sisi server dengan kunci terkelola Amazon S3 (SSE-S3). Namun, permintaan untuk mengonfigurasi fitur enkripsi default dikenakan biaya permintaan Amazon S3 standar. Untuk informasi tentang harga, lihat [Harga Amazon S3](https://aws.amazon.com/s3/pricing/).
Jika Anda mengharuskan unggahan data dienkripsi hanya menggunakan kunci terkelola Amazon S3, Anda dapat menggunakan kebijakan bucket berikut. Misalnya, kebijakan bucket berikut menolak izin untuk mengunggah objek kecuali jika permintaan mencakup header `x-amz-server-side-encryption` untuk meminta enkripsi di sisi server:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Id": "PutObjectPolicy",
"Statement": [
{
"Sid": "DenyObjectsThatAreNotSSES3",
"Effect": "Deny",
"Principal": "*",
"Action": "s3:PutObject",
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*",
"Condition": {
"StringNotEquals": {
"s3:x-amz-server-side-encryption": "AES256"
}
}
}
]
}
```
------
**catatan**
Enkripsi di sisi server hanya mengenkripsi data objek, bukan metadata objek.
## Dukungan API untuk enkripsi di sisi server
Semua bucket Amazon S3 memiliki enkripsi yang dikonfigurasi secara default, dan semua objek baru yang diunggah ke bucket S3 secara otomatis dienkripsi saat sedang tidak aktif. Enkripsi di sisi server dengan kunci terkelola Amazon S3 (SSE-S3) adalah konfigurasi enkripsi default untuk setiap bucket di Amazon S3. Untuk menggunakan jenis enkripsi yang berbeda, Anda dapat menentukan jenis enkripsi sisi server yang akan digunakan dalam `PUT` permintaan S3, atau memperbarui konfigurasi enkripsi default di bucket tujuan.
Jika Anda ingin menentukan jenis enkripsi yang berbeda dalam `PUT` permintaan Anda, Anda dapat menggunakan enkripsi sisi server dengan AWS Key Management Service () kunci (SSE-KMS AWS KMS), enkripsi sisi server dua lapis dengan kunci (DSSE-KMS), atau enkripsi sisi server dengan AWS KMS kunci yang disediakan pelanggan (SSE-C). Jika Anda ingin mengatur konfigurasi enkripsi default yang berbeda di dalam bucket tujuan, Anda dapat menggunakan SSE-KMS atau DSSE-KMS.
Untuk informasi selengkapnya tentang mengubah konfigurasi enkripsi default untuk bucket tujuan umum Anda, lihat[Mengonfigurasi enkripsi default](default-bucket-encryption.md).
Saat Anda mengubah konfigurasi enkripsi default bucket ke SSE-KMS, jenis enkripsi objek Amazon S3 yang ada di bucket tidak akan diubah. Untuk mengubah jenis enkripsi objek yang sudah ada sebelumnya setelah memperbarui konfigurasi enkripsi default ke SSE-KMS, Anda dapat menggunakan Operasi Batch Amazon S3. Anda menyediakan Operasi Batch S3 dengan daftar objek, dan Operasi Batch memanggil operasi API masing-masing. Anda dapat menggunakan [Menyalin objek](batch-ops-copy-object.md) tindakan untuk menyalin objek yang ada, yang menuliskannya kembali ke bucket yang sama dengan objek terenkripsi SSE-KMS. Satu tugas Operasi Batch dapat melakukan operasi tertentu pada miliaran objek yang berisi data sebesar eksabita. Untuk informasi selengkapnya, lihat [Melakukan operasi objek secara massal dengan Operasi Batch](batch-ops.md) dan posting *Blog AWS Penyimpanan* [Cara mengenkripsi objek yang ada secara surut di Amazon S3 menggunakan S3 Inventory, Amazon Athena, dan Operasi Batch S3](https://aws.amazon.com/blogs/security/how-to-retroactively-encrypt-existing-objects-in-amazon-s3-using-s3-inventory-amazon-athena-and-s3-batch-operations/).
Untuk mengkonfigurasi enkripsi sisi server dengan menggunakan REST pembuatan objek APIs, Anda harus memberikan header permintaan. `x-amz-server-side-encryption` Untuk informasi tentang REST APIs, lihat[Penggunaan API REST](specifying-s3-encryption.md#SSEUsingRESTAPI).
Amazon S3 berikut APIs mendukung header ini:
+ **Operasi PUT**–Tentukan header permintaan saat mengunggah data menggunakan API `PUT`. Untuk informasi lebih lanjut, lihat [PUT Objek](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPUT.html).
+ **Mulai Unggahan Multibagian**–Menentukan header dalam permintaan awal saat mengunggah objek besar menggunakan operasi API multibagian. Untuk informasi lebih lanjut, lihat [Mulai Unggahan Multibagian](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadInitiate.html).
+ **Operasi COPY**–Saat Anda menyalin objek, Anda memiliki objek sumber dan objek target. Untuk informasi lebih lanjut, lihat [PUT Objek-Salin](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectCOPY.html).
**catatan**
Saat menggunakan operasi `POST` untuk mengunggah objek, alih-alih memberikan header permintaan, Anda memberikan informasi yang sama di kolom formulir. Untuk informasi lebih lanjut, lihat [Objek POST](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPOST.html).
AWS SDKs Juga menyediakan pembungkus APIs yang dapat Anda gunakan untuk meminta enkripsi sisi server. Anda juga dapat menggunakan Konsol Manajemen AWS untuk mengunggah objek dan meminta enkripsi sisi server.
Untuk informasi lebih umum, lihat [AWS KMS konsep](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html) dalam *AWS Key Management Service Panduan Pengembang*.
**Topics**
+ [
## Dukungan API untuk enkripsi di sisi server
](#APISupportforServer-SideEncryption)
+ [
# Menentukan enkripsi di sisi server dengan kunci terkelola Amazon S3 (SSE-S3)
](specifying-s3-encryption.md)
# Menentukan enkripsi di sisi server dengan kunci terkelola Amazon S3 (SSE-S3)
Semua bucket Amazon S3 memiliki enkripsi yang dikonfigurasi secara default, dan semua objek baru yang diunggah ke bucket S3 secara otomatis dienkripsi saat sedang tidak aktif. Enkripsi di sisi server dengan kunci terkelola Amazon S3 (SSE-S3) adalah konfigurasi enkripsi default untuk setiap bucket di Amazon S3. Untuk menggunakan jenis enkripsi yang berbeda, Anda dapat menentukan jenis enkripsi sisi server yang akan digunakan dalam `PUT` permintaan S3, atau memperbarui konfigurasi enkripsi default di bucket tujuan.
Jika Anda ingin menentukan jenis enkripsi yang berbeda dalam `PUT` permintaan Anda, Anda dapat menggunakan enkripsi sisi server dengan AWS Key Management Service () kunci (SSE-KMS AWS KMS), enkripsi sisi server dua lapis dengan kunci (DSSE-KMS), atau enkripsi sisi server dengan AWS KMS kunci yang disediakan pelanggan (SSE-C). Jika Anda ingin mengatur konfigurasi enkripsi default yang berbeda di dalam bucket tujuan, Anda dapat menggunakan SSE-KMS atau DSSE-KMS.
Untuk informasi selengkapnya tentang mengubah konfigurasi enkripsi default untuk bucket tujuan umum Anda, lihat[Mengonfigurasi enkripsi default](default-bucket-encryption.md).
Saat Anda mengubah konfigurasi enkripsi default bucket ke SSE-KMS, jenis enkripsi objek Amazon S3 yang ada di bucket tidak akan diubah. Untuk mengubah jenis enkripsi objek yang sudah ada sebelumnya setelah memperbarui konfigurasi enkripsi default ke SSE-KMS, Anda dapat menggunakan Operasi Batch Amazon S3. Anda menyediakan Operasi Batch S3 dengan daftar objek, dan Operasi Batch memanggil operasi API masing-masing. Anda dapat menggunakan [Menyalin objek](batch-ops-copy-object.md) tindakan untuk menyalin objek yang ada, yang menuliskannya kembali ke bucket yang sama dengan objek terenkripsi SSE-KMS. Satu tugas Operasi Batch dapat melakukan operasi tertentu pada miliaran objek yang berisi data sebesar eksabita. Untuk informasi selengkapnya, lihat [Melakukan operasi objek secara massal dengan Operasi Batch](batch-ops.md) dan posting *Blog AWS Penyimpanan* [Cara mengenkripsi objek yang ada secara surut di Amazon S3 menggunakan S3 Inventory, Amazon Athena, dan Operasi Batch S3](https://aws.amazon.com/blogs/security/how-to-retroactively-encrypt-existing-objects-in-amazon-s3-using-s3-inventory-amazon-athena-and-s3-batch-operations/).
Anda dapat menentukan SSE-S3 dengan menggunakan konsol S3, REST APIs,, dan (). AWS SDKs AWS Command Line Interface AWS CLI Untuk informasi selengkapnya, lihat [Mengatur perilaku enkripsi sisi server default untuk bucket Amazon S3](bucket-encryption.md).
## Menggunakan konsol S3
Topik ini menjelaskan cara mengatur atau mengubah jenis enkripsi objek dengan menggunakan Konsol Manajemen AWS. Saat menyalin objek dengan menggunakan konsol, Amazon S3 menyalin objek seperti apa adanya. Itu berarti bahwa jika objek sumber dienkripsi, objek target juga dienkripsi. Anda dapat menggunakan konsol untuk menambahkan atau mengubah enkripsi untuk suatu objek.
**catatan**
Anda dapat mengubah enkripsi objek jika objek Anda kurang dari 5 GB. Jika objek Anda lebih besar dari 5 GB, Anda harus menggunakan [AWS CLI](mpu-upload-object.md#UsingCLImpUpload)atau [AWS SDKs](CopyingObjectsMPUapi.md)untuk mengubah enkripsi objek.
Untuk daftar izin tambahan yang diperlukan untuk mengubah enkripsi objek, lihat[Izin yang diperlukan untuk operasi API Amazon S3](using-with-s3-policy-actions.md). Misalnya kebijakan yang memberikan izin ini, lihat[Contoh kebijakan berbasis identitas untuk Amazon S3](example-policies-s3.md).
Jika Anda mengubah enkripsi objek, sebuah objek baru akan dibuat untuk menggantikan objek yang lama. Jika Penentuan Versi S3 diaktifkan, versi baru objek akan dibuat, dan objek yang sudah ada menjadi versi yang lebih lama. Peran yang mengubah properti juga menjadi pemilik objek baru (atau versi objek).
**Untuk mengubah enkripsi untuk objek**
1. Masuk ke Konsol Manajemen AWS dan buka konsol Amazon S3 di. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)
1. Di panel navigasi, pilih **Bucket**, lalu pilih tab **Bucket tujuan umum**. Arahkan ke bucket Amazon S3 atau folder yang berisi objek yang ingin Anda ubah.
1. Pilih kotak centang untuk objek yang ingin Anda ubah.
1. Pada menu **Tindakan**, pilih **Edit enkripsi sisi server** dari daftar opsi yang muncul.
1. Gulir ke bagian **enkripsi sisi server**.
1. Di bawah **Pengaturan enkripsi**, pilih **Gunakan pengaturan bucket untuk enkripsi default**, atau **Ganti pengaturan bucket untuk enkripsi default**.
1. Jika Anda memilih **Timpa pengaturan bucket untuk enkripsi default**, konfigurasikan pengaturan enkripsi berikut.
1. Di bawah **Jenis enkripsi**, pilih **Enkripsi sisi server dengan kunci terkelola Amazon S3 (SSE-S3)**. SSE-S3 menggunakan salah satu penyandian blok terkuat—Advanced Encryption Standard 256-bit (AES-256) untuk mengenkripsi setiap objek. Untuk informasi selengkapnya, lihat [Menggunakan enkripsi di sisi server dengan kunci terkelola Amazon S3 (SSE-S3)](UsingServerSideEncryption.md).
1. Di bawah **Pengaturan salinan tambahan**, pilih apakah Anda ingin **Menyalin setelan sumber**, **Jangan tentukan pengaturan**, atau **Tentukan pengaturan**. **Pengaturan sumber salin** adalah opsi default. Jika Anda hanya ingin menyalin objek tanpa atribut pengaturan sumber, pilih **Jangan tentukan pengaturan**. Pilih **Tentukan pengaturan** untuk menentukan pengaturan untuk kelas penyimpanan, tag objek ACLs, metadata, enkripsi sisi server, dan checksum tambahan.
1. Pilih **Simpan perubahan**.
**catatan**
Tindakan ini menerapkan enkripsi untuk semua objek yang ditentukan. Saat mengenkripsi folder, tunggu hingga operasi penyimpanannya selesai sebelum menambahkan objek baru ke folder tersebut.
## Penggunaan API REST
Saat pembuatan objek—yaitu, saat Anda mengunggah objek baru atau membuat salinan objek yang sudah ada—Anda dapat menentukan apakah Anda ingin Amazon S3 mengenkripsi data Anda dengan kunci yang dikelola Amazon S3 (SSE-S3) dengan menambahkan header ke permintaan `x-amz-server-side-encryption`. Mengatur nilai header ke algoritma enkripsi `AES256`, yang didukung Amazon S3. Amazon S3 mengonfirmasi bahwa objek Anda disimpan dengan SSE-S3 dengan mengembalikan header respons `x-amz-server-side-encryption`.
Operasi API unggahan REST berikut ini menerima header permintaan `x-amz-server-side-encryption`.
+ [PUT Objek](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPUT.html)
+ [PUT Objek-Salin](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectCOPY.html)
+ [Objek POST](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPOST.html)
+ [Mulai Unggahan Multibagian](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadInitiate.html)
Saat mengunggah objek besar menggunakan operasi API unggahan multibagian, Anda dapat menentukan enkripsi di sisi server dengan menambahkan `x-amz-server-side-encryption` header ke permintaan Mulai Pengunggahan Multibagian. Saat Anda menyalin objek yang ada, terlepas dari apakah objek sumbernya dienkripsi atau tidak, objek tujuan tidak dienkripsi kecuali jika Anda secara eksplisit meminta enkripsi di sisi server.
Header respons dari operasi API REST berikut mengembalikan `x-amz-server-side-encryption` header saat objek disimpan menggunakan SSE-S3.
+ [PUT Objek](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPUT.html)
+ [PUT Objek-Salin](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectCOPY.html)
+ [Objek POST](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPOST.html)
+ [Mulai Unggahan Multibagian](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadInitiate.html)
+ [Unggah Bagian](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadUploadPart.html)
+ [Unggah Bagian-Salin](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadUploadPartCopy.html)
+ [Selesaikan Unggahan Multibagian](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadComplete.html)
+ [Dapatkan Objek](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectGET.html)
+ [Head Objek](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectHEAD.html)
**catatan**
Jangan mengirim header permintaan enkripsi untuk `GET` permintaan dan `HEAD` minta jika objek Anda menggunakan SSE-S3, atau Anda akan mendapatkan kesalahan kode status HTTP 400 (Permintaan Buruk).
## Menggunakan AWS SDKs
Saat menggunakan AWS SDKs, Anda dapat meminta Amazon S3 untuk menggunakan enkripsi sisi server dengan kunci enkripsi terkelola Amazon S3 (SSE-S3). Bagian ini memberikan contoh penggunaan AWS SDKs dalam berbagai bahasa. Untuk informasi tentang lainnya SDKs, buka [Kode Sampel dan Perpustakaan](https://aws.amazon.com/code).
------
#### [ Java ]
Ketika Anda menggunakan AWS SDK untuk Java untuk meng-upload objek, Anda dapat menggunakan SSE-S3 untuk mengenkripsi itu. Untuk meminta enkripsi di sisi server, gunakan properti `ObjectMetadata` dari `PutObjectRequest` untuk menetapkan header permintaan `x-amz-server-side-encryption`. Saat Anda memanggil `putObject()` metode dari `AmazonS3Client`, Amazon S3 mengenkripsi dan menyimpan data.
Anda juga dapat meminta enkripsi SSE-S3 saat mengunggah objek menggunakan operasi API pengunggahan multibagian:
+ Saat menggunakan operasi API pengunggahan multibagian tingkat tinggi, Anda menggunakan metode `TransferManager` untuk menerapkan enkripsi di sisi server ke objek saat Anda mengunggahnya. Anda dapat menggunakan metode pengunggahan apa saja yang menggunakan `ObjectMetadata` sebagai parameter. Untuk informasi selengkapnya, lihat [Pengunggahan objek menggunakan unggahan multibagian](mpu-upload-object.md).
+ Saat menggunakan operasi API pengunggahan multibagian tingkat rendah, Anda menentukan enkripsi di sisi server saat Anda memulai pengunggahan multibagian. Anda menambahkan properti `ObjectMetadata` dengan memanggil metode `InitiateMultipartUploadRequest.setObjectMetadata()`. Untuk informasi selengkapnya, lihat [Menggunakan AWS SDKs (API tingkat rendah)](mpu-upload-object.md#mpu-upload-low-level).
Anda tidak dapat langsung mengubah status enkripsi suatu objek (mengenkripsi objek yang tidak dienkripsi atau mendekripsi objek yang dienkripsi). Untuk mengubah status enkripsi objek, Anda membuat salinan objek, dengan menentukan status enkripsi yang diinginkan untuk salinan, lalu hapus objek asli. Amazon S3 mengenkripsi objek yang disalin hanya jika Anda secara eksplisit meminta enkripsi di sisi server. Untuk meminta enkripsi objek yang disalin melalui API Java, gunakan properti `ObjectMetadata` untuk menentukan enkripsi di sisi server dalam `CopyObjectRequest`.
**Example Contoh**
Contoh berikut menunjukkan cara menetapkan enkripsi di sisi server menggunakan AWS SDK untuk Java. Itu menunjukkan cara melakukan tugas berikut:
+ Unggah objek baru menggunakan SSE-S3.
+ Ubah status enkripsi objek (dalam contoh ini, mengenkripsi objek yang tidak dienkripsi sebelumnya) dengan membuat salinan objek.
+ Periksa status enkripsi objek.
Untuk informasi lebih lanjut tentang enkripsi di sisi server, lihat [Penggunaan API REST](#SSEUsingRESTAPI). Untuk petunjuk cara membuat dan menguji sampel yang berfungsi, lihat [Memulai](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/getting-started.html) di Panduan AWS SDK untuk Java Pengembang.
```
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 ]
Saat mengunggah sebuah objek, Anda dapat mengarahkan Amazon S3 untuk mengenkripsinya. Untuk mengubah status enkripsi objek yang sudah ada, Anda membuat salinan objek dan menghapus objek sumber. Secara default, operasi penyalinan mengenkripsi target hanya jika Anda secara eksplisit meminta enkripsi di sisi server objek target. Untuk menentukan SSE-S3 di `CopyObjectRequest`, tambahkan yang berikut ini:
```
ServerSideEncryptionMethod = ServerSideEncryptionMethod.AES256
```
Untuk sampel kerja tentang cara menyalin objek, lihat [Menggunakan AWS SDKs](copy-object.md#CopyingObjectsUsingSDKs).
Contoh berikut mengunggah objek. Dalam permintaan, contoh tersebut mengarahkan Amazon S3 untuk mengenkripsi objek. Contoh tersebut kemudian mengambil metadata objek dan memverifikasi metode enkripsi yang digunakan. Untuk informasi tentang menyiapkan dan menjalankan contoh kode, lihat [Memulai SDK for .NET di AWSAWS SDK for](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/net-dg-setup.html) .NET *Developer Guide*.
```
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 ]
Topik ini menunjukkan cara menggunakan kelas dari versi 3 AWS SDK untuk PHP untuk menambahkan SSE-S3 ke objek yang Anda unggah ke Amazon S3. Untuk informasi selengkapnya tentang AWS SDK for Ruby API, [AWS buka SDK for Ruby](https://docs.aws.amazon.com/sdkforruby/api/index.html) - Versi 2.
Untuk mengunggah objek ke Amazon S3, gunakan metode [Aws\$1S3\$1S3Client::putObject()](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#putobject). Untuk menambahkan `x-amz-server-side-encryption` header permintaan ke permintaan pengunggahan, tentukan parameter `ServerSideEncryption` dengan nilai `AES256`, seperti yang ditunjukkan dalam contoh kode berikut. Untuk informasi lebih lanjut tentang permintaan enkripsi di sisi server, lihat [Penggunaan API REST](#SSEUsingRESTAPI).
```
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',
]);
```
Sebagai respons, Amazon S3 mengembalikan header `x-amz-server-side-encryption` dengan nilai algoritma enkripsi yang digunakan untuk mengenkripsi data objek Anda.
Saat mengunggah objek besar dengan menggunakan operasi API unggahan multibagian, Anda dapat menentukan SSE-S3 untuk objek yang Anda unggah, sebagai berikut ini:
+ Saat Anda menggunakan operasi API unggahan multibagian tingkat rendah, tentukan enkripsi sisi server saat Anda memanggil metode [Aws\$1 S3\$1 S3Client](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#createmultipartupload):: (). createMultipartUpload Untuk menambahkan header permintaan `x-amz-server-side-encryption` untuk permintaan Anda, tentukan parameter `array` kunci `ServerSideEncryption` dengan nilai `AES256`. Untuk informasi selengkapnya tentang operasi API unggahan multibagian tingkat rendah, lihat [Menggunakan AWS SDKs (API tingkat rendah)](mpu-upload-object.md#mpu-upload-low-level).
+ Saat Anda menggunakan operasi API unggahan multibagian tingkat tinggi, tentukan enkripsi sisi server dengan menggunakan `ServerSideEncryption` parameter operasi API. [CreateMultipartUpload](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#createmultipartupload) Untuk contoh penggunaan metode `setOption()` dengan operasi API unggahan multibagian tingkat tinggi, lihat [Pengunggahan objek menggunakan unggahan multibagian](mpu-upload-object.md).
Untuk menentukan status enkripsi objek yang ada, ambil metadata objek dengan memanggil metode [Aws\$1S3\$1S3Client::headObject()](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#headobject) seperti yang ditunjukkan dalam contoh kode PHP berikut.
```
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'];
```
Untuk mengubah status enkripsi objek yang sudah ada, buat salinan objek menggunakan metode [Aws\$1S3\$1S3Client::copyObject()](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#copyobject) dan menghapus objek sumber. Secara default, `copyObject()` tidak mengenkripsi target kecuali jika Anda secara eksplisit meminta enkripsi di sisi server objek tujuan menggunakan parameter `ServerSideEncryption` dengan nilai `AES256`. Contoh kode PHP berikut membuat salinan objek dan menambahkan enkripsi server-side ke objek yang tersalin.
```
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',
]);
```
Untuk informasi selengkapnya, lihat topik berikut:
+ [AWS SDK untuk PHP untuk Amazon S3 Aws\$1 S3\$1 S3Kelas Klien](https://docs.aws.amazon.com/aws-sdk-php/v3/api/class-Aws.S3.S3Client.html)
+ [Dokumentasi AWS SDK untuk PHP](https://aws.amazon.com/documentation/sdk-for-php/)
------
#### [ Ruby ]
Saat menggunakan AWS SDK untuk Ruby untuk mengunggah objek, Anda dapat menentukan bahwa objek disimpan terenkripsi saat istirahat dengan SSE-S3. Saat Anda membaca kembali, objek tersebut akan didekripsi secara otomatis.
Contoh AWS SDK untuk Ruby Versi 3 berikut menunjukkan cara menentukan bahwa file yang diunggah ke Amazon S3 dienkripsi saat istirahat.
```
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
bucket_name = "amzn-s3-demo-bucket"
object_key = "my-encrypted-content"
object_content = "This is my super-secret content."
encryption = "AES256"
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__
```
Contoh kode berikut menunjukkan cara menentukan status enkripsi objek yang ada.
```
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
bucket_name = "amzn-s3-demo-bucket"
object_key = "my-object.txt"
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__
```
Jika enkripsi di sisi server tidak digunakan untuk objek yang disimpan di Amazon S3, metode tersebut akan menghasilkan `null`.
Untuk mengubah status enkripsi objek yang ada, buat salinan objek tersebut dan hapus objek sumber. Secara default, metode penyalinan tidak mengenkripsi target kecuali Anda secara eksplisit meminta enkripsi di sisi server. Anda dapat meminta enkripsi objek target dengan menentukan nilai `server_side_encryption` dalam argumen hash opsi, seperti yang ditunjukkan dalam contoh kode Ruby berikut. Contoh kode mendemonstrasikan cara menyalin sebuah objek dan mengenkripsi salinan dengan 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
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 = 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__
```
------
## Menggunakan AWS CLI
Untuk menentukan SSE-S3 saat Anda mengunggah objek dengan menggunakan AWS CLI, gunakan contoh berikut.
```
aws s3api put-object --bucket amzn-s3-demo-bucket1 --key object-key-name --server-side-encryption AES256 --body file path
```
Untuk informasi selengkapnya, lihat [put-object](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/put-object.html) dalam *Referensi AWS CLI *. [Untuk menentukan SSE-S3 saat Anda menyalin objek dengan menggunakan AWS CLI, lihat copy-object.](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/copy-object.html)
## Menggunakan CloudFormation
*Untuk contoh pengaturan enkripsi menggunakan CloudFormation, lihat [Membuat bucket dengan enkripsi default](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-s3-bucket-serversideencryptionrule.html#aws-properties-s3-bucket-serversideencryptionrule--examples--Create_a_bucket_with_default_encryption) dan contoh [Membuat bucket dengan menggunakan enkripsi AWS KMS sisi server dengan S3 Bucket Key](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-s3-bucket-serversideencryptionrule.html#aws-properties-s3-bucket-serversideencryptionrule--examples--Create_a_bucket_using_AWS_KMS_server-side_encryption_with_an_S3_Bucket_Key) dalam `AWS::S3::Bucket ServerSideEncryptionRule` topik di Panduan Pengguna.AWS CloudFormation *