Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Menggunakan penyedia kredensi di AWS SDK for Java 2.x
Peran penyedia kredensial di dalamnya AWS SDK for Java 2.x adalah untuk mencari dan memasok kredensil ke klien SDK. Layanan AWS SDK menggunakan kredensil yang disumberkannya untuk mengautentikasi dengan layanan dengan menandatangani setiap permintaan secara kriptografis. Kredenal biasanya terdiri dari kunci akses—ID kunci akses dan kunci akses rahasia bersama-sama.
Saat Anda menggunakan kredensil sementara, yang digunakan saat Anda menyiapkan [konfigurasi penyedia token SSO atau mengonfigurasi](https://docs.aws.amazon.com/sdkref/latest/guide/feature-sso-credentials.html#sso-token-config) runtime Anda untuk [mengambil peran IAM (AWS Identity and Access Management)](https://docs.aws.amazon.com/sdkref/latest/guide/access-assume-role.html#credOrSourceAssumeRole) sebagai contoh, token sesi ditambahkan ke kunci akses, memberikan akses terbatas waktu ke sumber daya. AWS
Topik ini membahas beberapa cara Anda mengaktifkan SDK untuk mengakses kredensional.
**Topics**
+ [Pekerjaan pengembangan interaktif](credentials-temporary.md)
+ [Rantai penyedia kredensi default](credentials-chain.md)
+ [Caching kredensial](credential-caching.md)
+ [Tentukan penyedia kredensional tertentu](credentials-providers.md)
+ [Gunakan profil konfigurasi bersama](credentials-profiles.md)
+ [Gunakan proses eksternal](credentials-process.md)
+ [Menyediakan kredensi dalam kode](credentials-explicit.md)
+ [Baca kredensional peran IAM di Amazon EC2](ec2-iam-roles.md)
# Akses kredensional untuk pekerjaan pengembangan interaktif menggunakan AWS SDK for Java 2.x
Untuk meningkatkan keamanan, Anda AWS merekomendasikan agar Anda mengonfigurasi SDK for Java agar [menggunakan kredensil sementara](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#bp-users-federation-idp), bukan kredensial yang berumur panjang. Kredensi sementara terdiri dari kunci akses (id kunci akses dan kunci akses rahasia) dan token sesi.
Beberapa pendekatan tersedia bagi Anda untuk bekerja dengan kredensi sementara. Pendekatan yang Anda gunakan, dan oleh karena itu konfigurasi yang Anda berikan ke SDK, bergantung pada kasus penggunaan Anda.
Saat Anda melakukan pekerjaan pengembangan interaktif dengan Java SDK, kami sarankan Anda menggunakan kredensil login AWS Console.
## Menggunakan kredenal login konsol
Anda dapat menggunakan kredenal masuk Konsol AWS Manajemen yang sudah ada untuk akses terprogram ke layanan. AWS Setelah alur otentikasi berbasis browser, AWS menghasilkan kredensil sementara yang bekerja di seluruh alat pengembangan lokal seperti SDK for Java 2.x dan AWS CLI SDK for Java.
Dengan proses ini, Anda dapat mengautentikasi menggunakan kredensi root yang dibuat selama pengaturan akun awal, pengguna IAM, atau identitas federasi dari penyedia identitas Anda, dan AWS CLI secara otomatis mengelola kredensil sementara untuk Anda. Pendekatan ini meningkatkan keamanan dengan menghilangkan kebutuhan untuk menyimpan kredensi jangka panjang secara lokal.
Ketika Anda menjalankan `aws login` perintah, Anda dapat memilih dari sesi konsol aktif Anda, atau masuk melalui alur otentikasi berbasis browser dan ini akan secara otomatis menghasilkan kredensi sementara. SDK for Java 2.x akan secara otomatis me-refresh kredenal ini hingga 12 jam.
**penting**
Selain konfigurasi yang Anda tetapkan dalam file konfigurasi bersama yang berfungsi untuk semua proyek, setiap proyek Java individu memerlukan ketergantungan berikut dalam file `pom.xml` Maven:
```
software.amazon.awssdk
signin
```
`signin`Ketergantungan menyediakan kode yang memungkinkan SDK for Java 2.x mengakses dan menggunakan kredensi login konsol.
*Untuk informasi selengkapnya tentang prerequsites, masuk dan keluar, lihat [Login untuk pengembangan AWS lokal menggunakan kredenal konsol](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-sign-in.html) di SDK dan Panduan Refernce Tools.AWS *
## Single-sign-on pendekatan
Saat Anda melakukan pekerjaan pengembangan interaktif dengan Java SDK, Anda dapat menggunakan pendekatan masuk tunggal. Pendekatan ini membutuhkan pengaturan berikut:
+ [Diatur melalui Pusat Identitas IAM](get-started-auth.md#setup-auth)
+ [Konfigurasikan profil di file konfigurasi AWS bersama](get-started-auth.md#setup-credentials)
+ menggunakan AWS CLI dan [menjalankan perintah](get-started-auth.md#setup-login-sso) untuk login dan membuat sesi aktif
### Konfigurasi Pusat Identitas IAM
Saat Anda mengonfigurasi SDK untuk menggunakan akses masuk tunggal Pusat Identitas IAM seperti yang dijelaskan [Gambaran umum pengaturan](setup.md#setup-overview) dalam panduan ini, SDK menggunakan kredensil sementara.
SDK menggunakan token akses Pusat Identitas IAM untuk mendapatkan akses ke peran IAM yang dikonfigurasi dengan `sso_role_name` pengaturan di file Anda. `config` SDK mengasumsikan peran IAM ini dan mengambil kredenal sementara untuk menandatangani permintaan. Layanan AWS
Untuk detail selengkapnya tentang cara SDK mendapatkan kredensil sementara dari konfigurasi, lihat bagian [Memahami autentikasi Pusat Identitas IAM](https://docs.aws.amazon.com/sdkref/latest/guide/understanding-sso.html) pada Panduan Referensi Alat dan Panduan Referensi Alat. AWS SDKs
**penting**
Selain konfigurasi yang Anda tetapkan dalam `config` file bersama yang berfungsi untuk semua proyek, setiap proyek Java individu memerlukan dependensi berikut dalam file `pom.xml` Maven:
```
software.amazon.awssdk
sso
software.amazon.awssdk
ssooidc
```
`ssooidc`Dependensi `sso` dan menyediakan kode yang memungkinkan SDK for Java 2.x mengakses kredensi sementara.
### Ambil kredensi sementara dari portal akses AWS
Sebagai alternatif untuk konfigurasi masuk tunggal Pusat Identitas IAM, Anda dapat menyalin dan menggunakan kredenal sementara yang tersedia di portal akses. AWS Anda dapat menggunakan kredensi sementara di profil atau menggunakannya sebagai nilai untuk properti sistem dan variabel lingkungan.
**Siapkan file kredensial lokal untuk kredensil sementara**
1. [Buat file kredensial bersama](https://docs.aws.amazon.com/sdkref/latest/guide/file-location.html)
1. Dalam file kredensial, rekatkan teks placeholder berikut hingga Anda menempelkan kredensi sementara yang berfungsi.
```
[default]
aws_access_key_id=
aws_secret_access_key=
aws_session_token=
```
1. Simpan file tersebut. File sekarang `~/.aws/credentials` harus ada di sistem pengembangan lokal Anda. File ini berisi [profil [default]](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html#file-format-profile) yang digunakan SDK for Java jika profil bernama tertentu tidak ditentukan.
1. [Masuk ke portal AWS akses](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtosignin.html)
1. Ikuti petunjuk ini di bawah judul [penyegaran kredenal manual](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtogetcredentials.html#how-to-get-temp-credentials) untuk menyalin kredensi peran IAM dari portal akses. AWS
1. Untuk langkah 2 dalam petunjuk yang ditautkan, pilih `Access keys` nama peran IAM yang memberikan akses untuk kebutuhan pengembangan Anda. Peran ini biasanya memiliki nama seperti **PowerUserAccess**atau **Pengembang**.
1. Di kotak dialog modal, pilih sistem operasi Anda dan salin isinya dari **Tambahkan profil ke file AWS kredensil Anda**.
1. Tempelkan kredenal yang disalin ke `credentials` file lokal Anda dan hapus nama profil yang dihasilkan. File Anda harus menyerupai yang berikut ini.
```
[default]
aws_access_key_id=AKIAIOSFODNN7EXAMPLE
aws_secret_access_key=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
aws_session_token=IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZVERYLONGSTRINGEXAMPLE
```
1. Simpan file `credentials`.
Ketika SDK for Java membuat klien layanan, itu akan mengakses kredensil sementara ini dan menggunakannya untuk setiap permintaan. Pengaturan untuk peran IAM yang dipilih pada langkah 5a menentukan [berapa lama kredensi sementara valid](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtosessionduration.html). Durasi maksimum adalah dua belas jam.
Setelah kredensi sementara kedaluwarsa, ulangi langkah 4 hingga 7.
# Rantai penyedia kredensi default di AWS SDK for Java 2.x
Rantai penyedia kredensi default dalam pencarian AWS kredensil AWS SDK for Java 2.x secara otomatis dalam urutan lokasi yang telah ditentukan sebelumnya, memungkinkan aplikasi untuk mengautentikasi dengan tanpa secara eksplisit menentukan sumber kredensi. Layanan AWS
Rantai penyedia kredensi default diimplementasikan oleh kelas. [DefaultCredentialsProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/auth/credentials/DefaultCredentialsProvider.html) Ini secara berurutan mendelegasikan ke implementasi penyedia kredensional lain yang memeriksa konfigurasi di berbagai lokasi. Penyedia kredensi pertama yang dapat menemukan semua elemen konfigurasi yang diperlukan menyebabkan rantai berakhir.
Untuk menggunakan rantai penyedia kredensi default untuk menyediakan kredensil sementara, buat pembuat klien layanan tetapi jangan tentukan penyedia kredensional. Cuplikan kode berikut membuat `DynamoDbClient` yang menggunakan rantai penyedia kredensial default untuk mencari dan mengambil pengaturan konfigurasi.
```
// Any external Region configuration is overridden.
// The SDK uses the default credentials provider chain because no specific credentials provider is specified.
Region region = Region.US_WEST_2;
DynamoDbClient ddb =
DynamoDbClient.builder()
.region(region)
.build();
```
## Urutan pengambilan setelan kredensialnya
Rantai penyedia kredensial default SDK for Java 2.x mencari konfigurasi di lingkungan Anda menggunakan urutan yang telah ditentukan sebelumnya.
1. Properti sistem Java
+ SDK menggunakan [SystemPropertyCredentialsProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/auth/credentials/SystemPropertyCredentialsProvider.html)kelas untuk memuat kredensi sementara dari properti sistem`aws.accessKeyId`,`aws.secretAccessKey`, dan `aws.sessionToken` Java.
**catatan**
Untuk informasi tentang cara mengatur properti sistem Java, lihat tutorial [System Properties](https://docs.oracle.com/javase/tutorial/essential/environment/sysprop.html) di situs web resmi *Java Tutorial*.
1. Variabel-variabel lingkungan
+ SDK menggunakan [EnvironmentVariableCredentialsProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/auth/credentials/EnvironmentVariableCredentialsProvider.html)kelas untuk memuat kredenal sementara dari variabel`AWS_ACCESS_KEY_ID`,`AWS_SECRET_ACCESS_KEY`, dan `AWS_SESSION_TOKEN` lingkungan.
1. Token identitas web dan peran IAM ARN
+ SDK menggunakan [WebIdentityTokenFileCredentialsProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/auth/credentials/WebIdentityTokenFileCredentialsProvider.html)kelas untuk memuat kredensil dengan mengasumsikan peran menggunakan token identitas web.
+ Penyedia kredensial mencari variabel lingkungan berikut atau properti sistem JVM:
+ `AWS_WEB_IDENTITY_TOKEN_FILE or aws.webIdentityTokenFile`
+ `AWS_ROLE_ARN` atau `aws.roleArn`
+ `AWS_ROLE_SESSION_NAME`atau `aws.roleSessionName` (opsional)
+ Setelah SDK memperoleh nilai, ia memanggil AWS Security Token Service (STS) dan menggunakan kredensil sementara yang dikembalikan untuk menandatangani permintaan.
+ Lingkungan runtime seperti Amazon Elastic Kubernetes Service (EKS) secara otomatis membuat token identitas web AWS SDKs tersedia, memungkinkan aplikasi memperoleh kredensi sementara. AWS
1. Yang dibagikan `credentials` dan `config` file
+ SDK menggunakan pengaturan masuk tunggal IAM Identity Center atau kredensil sementara dari `[default]` profil di file bersama dan file. [ProfileCredentialsProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/auth/credentials/ProfileCredentialsProvider.html)`credentials``config`
Panduan Referensi AWS SDKs and Tools memiliki [informasi terperinci](https://docs.aws.amazon.com/sdkref/latest/guide/understanding-sso.html#idccredres) tentang cara kerja SDK for Java dengan token masuk tunggal IAM Identity Center untuk mendapatkan kredenal sementara yang digunakan SDK untuk memanggil. Layanan AWS
**catatan**
`config`File `credentials` dan dibagikan oleh berbagai AWS SDKs dan Alat. Untuk informasi lebih lanjut, lihat [The. aws/credentials and .aws/config](https://docs.aws.amazon.com/sdkref/latest/guide/creds-config-files.html)file di Panduan Referensi Alat AWS SDKs dan.
+ Karena profil di berbagi `credentials` dan `config` file dapat berisi banyak set pengaturan yang berbeda, `ProfileCredentialsProvider` delegasi ke serangkaian penyedia lain untuk mencari pengaturan di bawah `[default]` profil:
+ **Kredensial token identitas web** (kelas`WebIdentityTokenCredentialsProvider`): Ketika profil berisi `role_arn` dan. `web_identity_token_file`
+ **Kredensial SSO** (kelas`SsoCredentialsProvider`): Ketika profil berisi properti terkait SSO seperti,. `sso_role_name` `sso_account_id`
+ **Kredensial berbasis peran dengan profil sumber** (kelas`StsAssumeRoleCredentialsProvider`): Ketika profil berisi dan. `role_arn` `source_profile`
+ **Kredensial berbasis peran dengan sumber kredensi** (kelas`StsAssumeRoleWithSourceCredentialsProvider`): Saat profil berisi dan. `role_arn` `credential_source`
+ Kapan`credential_source = Environment`: Menggunakan rantai `SystemPropertyCredentialsProvider` dan `EnvironmentVariableCredentialsProvider`
+ Kapan`credential_source = Ec2InstanceMetadata`: Ini menggunakan `InstanceProfileCredentialsProvider`
+ Kapan`credential_source = EcsContainer`: Ini menggunakan `ContainerCredentialsProvider`
+ **Kredensial login konsol** (kelas`LoginCredentialsProvider`): Saat profil berisi `login_session`
+ **Kredensi proses** (kelas`ProcessCredentialsProvider`): Ketika profil berisi. `credential_process`
+ **Kredensial sesi** (kelas`StaticSessionCredentialsProvider`): Ketika profil berisi`aws_access_key_id`,`aws_secret_access_key`, dan. `aws_session_token`
+ **Kredensi dasar** (kelas`StaticCredentialsProvider`): Ketika profil berisi `aws_access_key_id` dan. `aws_secret_access_key`
1. Amazon ECS kredensi kontainer
+ SDK menggunakan [ContainerCredentialsProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/auth/credentials/ContainerCredentialsProvider.html)kelas untuk memuat kredenal sementara menggunakan variabel lingkungan berikut:
1. `AWS_CONTAINER_CREDENTIALS_RELATIVE_URI` atau `AWS_CONTAINER_CREDENTIALS_FULL_URI`
1. `AWS_CONTAINER_AUTHORIZATION_TOKEN_FILE` atau `AWS_CONTAINER_AUTHORIZATION_TOKEN`
Agen kontainer ECS secara otomatis menetapkan variabel `AWS_CONTAINER_CREDENTIALS_RELATIVE_URI` lingkungan, yang menunjuk ke titik akhir kredensi ECS. Variabel lingkungan lainnya biasanya diatur dalam skenario tertentu di mana titik akhir kredensi ECS standar tidak digunakan.
1. Amazon EC2 kredensi yang disediakan peran IAM misalnya
+ SDK menggunakan [InstanceProfileCredentialsProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/auth/credentials/InstanceProfileCredentialsProvider.html)kelas untuk memuat kredensil sementara dari layanan metadata. Amazon EC2
1. Jika SDK tidak dapat menemukan pengaturan konfigurasi yang diperlukan melalui semua langkah yang tercantum di atas, SDK akan menampilkan pengecualian dengan output yang mirip dengan berikut ini:
```
software.amazon.awssdk.core.exception.SdkClientException: Unable to load credentials from any of the providers
in the chain AwsCredentialsProviderChain(credentialsProviders=[SystemPropertyCredentialsProvider(),
EnvironmentVariableCredentialsProvider(), WebIdentityTokenCredentialsProvider(), ProfileCredentialsProvider(),
ContainerCredentialsProvider(), InstanceProfileCredentialsProvider()])
```
## Gunakan kode `DefaultCredentialsProvider` dalam
Anda dapat secara eksplisit menggunakan rantai penyedia kredensi default dalam kode Anda. Ini secara fungsional setara dengan Anda yang tidak menentukan penyedia kredensional sama sekali, karena SDK digunakan secara default. `DefaultCredentialsProvider` Namun, menggunakannya secara eksplisit dapat membuat kode Anda lebih mudah dibaca dan didokumentasikan sendiri. Ini jelas menunjukkan niat Anda untuk menggunakan rantai kredensional default.
```
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.s3.S3Client;
public class ExplicitDefaultCredentialsExample {
public static void main(String[] args) {
// Explicitly create the DefaultCredentialsProvider.
DefaultCredentialsProvider defaultCredentialsProvider = DefaultCredentialsProvider
.builder().build();
// Use it with any service client.
S3Client s3Client = S3Client.builder()
.region(Region.US_WEST_2)
.credentialsProvider(defaultCredentialsProvider)
.build();
// Now you can use the client with the default credentials chain.
s3Client.listBuckets();
}
}
```
Saat Anda membangun penyedia kredensi default, Anda dapat menyediakan lebih banyak konfigurasi:
```
DefaultCredentialsProvider customizedProvider = DefaultCredentialsProvider.builder()
.profileName("custom-profile") // Use a specific profile if the chain gets to the `ProfileCredentialsProvider` stage.
.asyncCredentialUpdateEnabled(true) // Enable async credential updates.
.build();
```
Pendekatan ini memberi Anda lebih banyak kontrol sambil tetap memberikan kenyamanan rantai kredensil default.
# Caching kredensial di AWS SDK for Java 2.x
AWS SDK for Java 2.x Mengimplementasikan caching kredenal untuk meningkatkan kinerja dan mengurangi panggilan ke sumber kredensional. Bagian ini menjelaskan cara kerja caching kredensil dan bagaimana Anda dapat mengonfigurasinya untuk aplikasi Anda.
## Memahami caching penyedia kredensi
Penyedia kredensi di SDK for Java 2.x menggunakan strategi caching yang berbeda:
+ **Caching kredenal internal**: Banyak penyedia menyimpan kredensi cache yang mereka ambil.
+ **Penyegaran otomatis**: Penyedia dengan kredenal cache menerapkan mekanisme penyegaran.
### Penyedia dengan caching kredensil internal
Penyedia kredensial berikut menyimpan kredensil secara internal, bahkan saat Anda membuat instance baru:
+ **Penyedia kredensial profil instans**: Cache kredensional dari layanan metadata Amazon EC2.
+ **Penyedia kredensial kontainer**: Cache kredensil dari titik akhir metadata kontainer.
+ **Penyedia berbasis STS**: Cache kredensi sementara dari AWS Security Token Service (STS).
+ **Penyedia token identitas web**: Kredensi cache yang diperoleh dari token identitas web.
+ **Process credentials provider**: Cache kredensial dari proses eksternal.
### Penyedia tanpa caching internal
Penyedia berikut tidak menerapkan caching internal:
+ **Penyedia Kredensial Variabel Lingkungan**
+ **Penyedia Kredensial Properti Sistem**
+ **Penyedia Kredensial Statis**
## Mengkonfigurasi caching kredenal
Anda dapat menyesuaikan perilaku caching saat membuat penyedia kredensi:
### Waktu Basi
Kontrol saat kredensional dianggap basi dan perlu disegarkan:
```
.staleTime(Duration.ofMinutes(2)) // Consider stale 2 minutes before expiration.
```
### Waktu Prefetch
Menentukan kapan harus mulai menyegarkan kredensi sebelum kedaluwarsa:
```
.prefetchTime(Duration.ofMinutes(10)) // Start refresh 10 minutes before expiration.
```
### Pembaruan Asinkron
Mengaktifkan penyegaran kredenal latar belakang:
```
.asyncCredentialUpdateEnabled(true) // Refresh credentials in background thread.
```
### Durasi Sesi
Untuk penyedia berbasis STS, mengontrol berapa lama kredensi sementara tetap valid:
```
.refreshRequest(r -> r.durationSeconds(3600)) // 1 hour session.
```
## Contoh konfigurasi kredensial caching
Sebagai contoh mengonfigurasi caching untuk implementasi penyedia kredensional, Anda mungkin ingin SDK menggunakan utas latar belakang untuk mengambil (mengambil terlebih dahulu) kredensil sebelum kedaluwarsa. Dengan begitu Anda dapat menghindari panggilan pemblokiran yang mengambil kredensi baru.
Berikut ini menunjukkan contoh yang membuat thread `[StsAssumeRoleCredentialsProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sts/auth/StsAssumeRoleCredentialsProvider.html)` yang menggunakan thread latar belakang untuk mengambil kredenal sebelumnya dengan menyetel `[asyncCredentialUpdateEnabled](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sts/auth/StsCredentialsProvider.BaseBuilder.html#asyncCredentialUpdateEnabled(java.lang.Boolean))` properti ke `true` pada builder:
```
StsAssumeRoleCredentialsProvider provider = StsAssumeRoleCredentialsProvider.builder()
.refreshRequest(r -> r
.roleArn("arn:aws:iam::111122223333:role/example-role")
.roleSessionName("example-session")
.durationSeconds(3600)) // 1 hour session
.staleTime(Duration.ofMinutes(5)) // Consider stale 5 minutes before expiration
.prefetchTime(Duration.ofMinutes(10)) // Start refresh 10 minutes before expiration
.asyncCredentialUpdateEnabled(true) // Refresh in background
.build();
S3Client s3 = S3Client.builder()
.credentialsProvider(provider)
.build();
```
Ketika Anda menjalankan operasi `s3Client` untuk pertama kalinya, an `[AssumeRoleRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sts/model/AssumeRoleRequest.html)` dikirim ke AWS Security Token Service (STS). STS mengembalikan kredensi sementara yang berlaku selama 15 menit (900 detik). `s3Client`Instance menggunakan kredensil yang di-cache hingga waktunya untuk menyegarkannya sebelum 15 menit berlalu. Secara default, SDK mencoba mengambil kredensi baru untuk sesi baru antara 5 menit dan 1 menit sebelum waktu kedaluwarsa sesi saat ini. Jendela pre-fetch dapat dikonfigurasi dengan menggunakan properti and. `[prefetchTime](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sts/auth/StsCredentialsProvider.BaseBuilder.html#prefetchTime(java.time.Duration))` `[staleTime](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sts/auth/StsCredentialsProvider.BaseBuilder.html#staleTime(java.time.Duration))`
Anda dapat mengonfigurasi penyedia kredensi berbasis sesi berikut dengan cara yang sama:
+ `StsWebIdentityTokenFileCredentialsProvider`
+ `StsGetSessionTokenCredentialsProvider`
+ `StsGetFederationTokenCredentialsProvider`
+ `StsAssumeRoleWithWebIdentityCredentialsProvider`
+ `StsAssumeRoleWithSamlCredentialsProvider`
+ `StsAssumeRoleCredentialsProvider`
+ `DefaultCredentialsProvider`(saat mendelegasikan ke penyedia kredensional yang menggunakan sesi)
+ `ProcessCredentialsProvider`
+ `WebIdentityTokenFileCredentialsProvider`
+ `ContainerCredentialsProvider`
+ `InstanceProfileCredentialsProvider`
Memahami caching kredenal membantu Anda mengoptimalkan kinerja dan keandalan aplikasi saat bekerja dengannya. Layanan AWS
# Tentukan penyedia kredensi tertentu di AWS SDK for Java 2.x
Meskipun rantai penyedia kredensional default nyaman untuk banyak skenario, menentukan penyedia kredensional secara eksplisit memberi Anda kontrol yang lebih besar atas perilaku otentikasi, kinerja, dan keamanan.
Alasan mengapa Anda mungkin ingin menentukan penyedia kredensional mungkin termasuk:
+ Rantai penyedia default memeriksa beberapa sumber secara berurutan, yang dapat menambahkan latensi:
```
// The default provider chain checks might check multiple sources until it finds
// sufficient configuration.
S3Client s3Client = S3Client.builder().build();
// You can specify exactly where to look.
S3Client optimizedClient = S3Client.builder()
.credentialsProvider(InstanceProfileCredentialsProvider.create())
.build();
```
+ Anda perlu menggunakan lokasi non-standar untuk mengakses konfigurasi kredensional:
```
// Use configuration from a custom file location.
S3Client s3Client = S3Client.builder()
.credentialsProvider(ProfileCredentialsProvider.builder()
.profileFile(ProfileFile.builder()
.content(Paths.get("/custom/path/to/configuration/file"))
.type(ProfileFile.Type.CONFIGURATION) // Expects all non-default profiles to be prefixed with "profile".
.build())
.profileName("custom")
.build())
.build();
```
+ Gunakan kredensi yang berbeda untuk klien layanan yang berbeda. Misalnya, jika aplikasi Anda perlu mengakses beberapa AWS akun atau menggunakan izin yang berbeda untuk layanan yang berbeda:
```
// S3 client using one set of credentials.
S3Client s3Client = S3Client.builder()
.credentialsProvider(ProfileCredentialsProvider.create("s3-readonly"))
.build();
// DynamoDB client using different credentials.
DynamoDbClient dynamoDbClient = DynamoDbClient.builder()
.credentialsProvider(ProfileCredentialsProvider.create("dynamodb-admin"))
.build();
```
+ Kontrol perilaku penyegaran kredenal:
```
// Create a provider with custom refresh behavior.
StsAssumeRoleCredentialsProvider customRefreshProvider =
StsAssumeRoleCredentialsProvider.builder()
.refreshRequest(AssumeRoleRequest.builder()
.roleArn("arn:aws:iam::123456789012:role/my-role")
.roleSessionName("custom-session")
.build())
.stsClient(StsClient.create())
.asyncCredentialUpdateEnabled(true) // Use a background thread to prefetch credentials.
.build();
S3Client s3Client = S3Client.builder()
.credentialsProvider(customRefreshProvider)
.build();
```
# Gunakan profil konfigurasi AWS bersama di AWS SDK for Java 2.x
Menggunakan `credentials` file bersama `config` dan, Anda dapat mengatur beberapa profil. Hal ini memungkinkan aplikasi Anda untuk menggunakan beberapa set konfigurasi kredensional. `[default]`Profil tersebut telah disebutkan sebelumnya. SDK menggunakan [ProfileCredentialsProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/auth/credentials/ProfileCredentialsProvider.html)kelas untuk memuat pengaturan dari profil yang ditentukan dalam `credentials` file bersama.
Cuplikan kode berikut menunjukkan cara membangun klien layanan yang menggunakan pengaturan yang didefinisikan sebagai bagian dari profil bernama. `my_profile`
```
Region region = Region.US_WEST_2;
DynamoDbClient ddb = DynamoDbClient.builder()
.region(region)
.credentialsProvider(ProfileCredentialsProvider.create("my_profile"))
.build();
```
## Tetapkan profil yang berbeda sebagai default
Untuk menetapkan profil selain `[default]` profil sebagai default untuk aplikasi Anda, atur variabel `AWS_PROFILE` lingkungan ke nama profil kustom Anda.
Untuk mengatur variabel ini di Linux, macOS, atau Unix, gunakan: `export`
```
export AWS_PROFILE="other_profile"
```
Untuk menetapkan variabel ini di Windows, gunakan `set`:
```
set AWS_PROFILE="other_profile"
```
Atau, atur properti sistem `aws.profile` Java ke nama profil.
## Muat ulang kredensi profil
Anda dapat mengonfigurasi penyedia kredensi apa pun yang memiliki `profileFile()` metode pada pembuatnya untuk memuat ulang kredensi profil. Kelas profil kredensional ini adalah:`ProfileCredentialsProvider`,,`DefaultCredentialsProvider`, dan `InstanceProfileCredentialsProvider` `ProfileTokenProvider.`
**catatan**
Pemuatan ulang kredenal profil hanya berfungsi dengan pengaturan berikut di file profil:`aws_access_key_id`,`aws_secret_access_key`, dan. `aws_session_token`
Pengaturan seperti`region`,`sso_session`,`sso_account_id`, dan `source_profile` diabaikan.
Untuk mengonfigurasi penyedia kredensi yang didukung untuk memuat ulang setelan profil, berikan instance [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/profiles/ProfileFileSupplier.html](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/profiles/ProfileFileSupplier.html)ke metode `profileFile()` pembangun. Contoh kode berikut menunjukkan `ProfileCredentialsProvider` yang memuat ulang pengaturan kredensi dari profil. `[default]`
```
ProfileCredentialsProvider provider = ProfileCredentialsProvider
.builder()
.profileFile(ProfileFileSupplier.defaultSupplier())
.build();
// Set up a service client with the provider instance.
DynamoDbClient dynamoDbClient = DynamoDbClient.builder()
.region(Region.US_EAST_1)
.credentialsProvider(provider)
.build();
/*
Before dynamoDbClient makes a request, it reloads the credentials settings
by calling provider.resolveCredentials().
*/
```
Ketika `ProfileCredentialsProvider.resolveCredentials()` dipanggil, SDK for Java memuat ulang pengaturan. `ProfileFileSupplier.defaultSupplier()`adalah salah satu dari [beberapa implementasi kenyamanan](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/profiles/ProfileFileSupplier.html) yang `ProfileFileSupplier` disediakan oleh SDK. Jika kasus penggunaan Anda membutuhkan, Anda dapat memberikan implementasi Anda sendiri.
Contoh berikut menunjukkan penggunaan metode `ProfileFileSupplier.reloadWhenModified()` kenyamanan. `reloadWhenModified()`mengambil `Path` parameter, yang memberi Anda fleksibilitas dalam menunjuk file sumber untuk konfigurasi daripada lokasi standar `~/.aws/credentials` (atau`config`).
Pengaturan akan dimuat ulang ketika `resolveCredentials()` dipanggil hanya jika SDK menentukan konten file telah dimodifikasi.
```
Path credentialsFilePath = ...
ProfileCredentialsProvider provider = ProfileCredentialsProvider
.builder()
.profileFile(ProfileFileSupplier.reloadWhenModified(credentialsFilePath, ProfileFile.Type.CREDENTIALS))
.profileName("my-profile")
.build();
/*
A service client configured with the provider instance calls provider.resolveCredential()
before each request.
*/
```
`ProfileFileSupplier.aggregate()`Metode ini menggabungkan isi dari beberapa file konfigurasi. Anda memutuskan apakah file dimuat ulang per panggilan ke `resolveCredentials()` atau pengaturan file diperbaiki pada saat pertama kali dibaca.
Contoh berikut menunjukkan `DefaultCredentialsProvider` yang menggabungkan pengaturan dua file yang berisi pengaturan profil. SDK memuat ulang pengaturan dalam file yang ditunjuk oleh `credentialsFilePath` variabel setiap kali `resolveCredentials()` dipanggil dan pengaturan telah berubah. Pengaturan dari `profileFile` objek tetap sama.
```
Path credentialsFilePath = ...;
ProfileFile profileFile = ...;
DefaultCredentialsProvider provider = DefaultCredentialsProvider
.builder()
.profileFile(ProfileFileSupplier.aggregate(
ProfileFileSupplier.reloadWhenModified(credentialsFilePath, ProfileFile.Type.CREDENTIALS),
ProfileFileSupplier.fixedProfileFile(profileFile)))
.profileName("my-profile")
.build();
/*
A service client configured with the provider instance calls provider.resolveCredential()
before each request.
*/
```
# Muat kredensi dari proses eksternal menggunakan AWS SDK for Java 2.x
**Awas**
Berikut ini menjelaskan metode sumber kredensi sementara dari proses eksternal. Ini berpotensi berbahaya, jadi lanjutkan dengan hati-hati. Kami menyarankan Anda menggunakan penyedia kredensi lain jika memungkinkan. Jika menggunakan opsi ini, kami sarankan Anda memastikan `config` file dikunci sebanyak mungkin menggunakan praktik terbaik keamanan untuk sistem operasi Anda.
Pastikan alat kredensi kustom Anda tidak menulis informasi rahasia apa pun. `StdErr` SDKs dan AWS CLI dapat menangkap dan mencatat informasi tersebut, berpotensi mengeksposnya kepada pengguna yang tidak sah.
Dengan SDK for Java 2.x, Anda dapat memperoleh kredensi sementara dari proses eksternal untuk kasus penggunaan kustom. Ada dua cara untuk mengkonfigurasi fungsi ini.
## Gunakan `credential_process` pengaturan
Jika Anda memiliki metode yang menyediakan kredensil sementara, Anda dapat mengintegrasikannya dengan menambahkan `credential_process` pengaturan sebagai bagian dari definisi profil dalam file. `config` Nilai yang Anda tentukan harus menggunakan path lengkap ke file perintah. Jika jalur file berisi spasi apa pun, Anda harus mengelilinginya dengan tanda kutip.
SDK memanggil perintah persis seperti yang diberikan dan kemudian membaca data JSON dari. `stdout`
Contoh berikut menunjukkan penggunaan pengaturan ini untuk jalur file tanpa spasi dan jalur file dengan spasi.
------
#### [ Linux/macOS ]
**Tidak ada spasi di jalur file**
```
[profile process-credential-profile]
credential_process = /path/to/credential/file/credential_file.sh --custom-command custom_parameter
```
**Spasi di jalur file**
```
[profile process-credential-profile]
credential_process = "/path/with/space to/credential/file/credential_file.sh" --custom-command custom_parameter
```
------
#### [ Windows ]
**Tidak ada spasi di jalur file**
```
[profile process-credential-profile]
credential_process = C:\Path\To\credentials.cmd --custom_command custom_parameter
```
**Spasi di jalur file**
```
[profile process-credential-profile]
credential_process = "C:\Path\With Space To\credentials.cmd" --custom_command custom_parameter
```
------
Cuplikan kode berikut menunjukkan cara membangun klien layanan yang menggunakan kredenal sementara yang didefinisikan sebagai bagian dari profil bernama. `process-credential-profile`
```
Region region = Region.US_WEST_2;
S3Client s3Client = S3Client.builder()
.region(region)
.credentialsProvider(ProfileCredentialsProvider.create("process-credential-profile"))
.build();
```
Untuk informasi rinci tentang menggunakan proses eksternal sebagai sumber kredensional sementara, lihat [bagian kredensial proses di Panduan](https://docs.aws.amazon.com/sdkref/latest/guide/feature-process-credentials.html) Referensi AWS SDKs dan Alat.
## Gunakan `ProcessCredentialsProvider`
Sebagai alternatif untuk menggunakan pengaturan dalam `config` file, Anda dapat menggunakan SDK `[ProcessCredentialsProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/auth/credentials/ProcessCredentialsProvider.html)` untuk memuat kredenal sementara menggunakan Java.
Contoh berikut menunjukkan berbagai versi cara menentukan proses eksternal menggunakan `ProcessCredentialsProvider` dan mengkonfigurasi klien layanan yang menggunakan kredensil sementara.
------
#### [ Linux/macOS ]
**Tidak ada spasi di jalur file**
```
ProcessCredentialsProvider credentials =
ProcessCredentialsProvider
.builder()
.command("/path/to/credentials.sh optional_param1 optional_param2")
.build();
S3Client s3 = S3Client.builder()
.region(Region.US_WEST_2)
.credentialsProvider(credentials)
.build();
```
**Spasi di jalur file**
```
ProcessCredentialsProvider credentials =
ProcessCredentialsProvider
.builder()
.command("/path\\ with\\ spaces\\ to/credentials.sh optional_param1 optional_param2")
.build();
S3Client s3 = S3Client.builder()
.region(Region.US_WEST_2)
.credentialsProvider(credentials)
.build();
```
------
#### [ Windows ]
**Tidak ada spasi di jalur file**
```
ProcessCredentialsProvider credentials =
ProcessCredentialsProvider
.builder()
.command("C:\\Path\\To\\credentials.exe optional_param1 optional_param2")
.build();
S3Client s3 = S3Client.builder()
.region(Region.US_WEST_2)
.credentialsProvider(credentials)
.build();
```
**Spasi di jalur file**
```
ProcessCredentialsProvider credentials =
ProcessCredentialsProvider
.builder()
.command("\"C:\\Path\\With Spaces To\\credentials.exe\" optional_param1 optional_param2")
.build();
S3Client s3 = S3Client.builder()
.region(Region.US_WEST_2)
.credentialsProvider(credentials)
.build();
```
------
## Gunakan Peran IAM Di Mana Saja untuk otentikasi
[IAM Roles Anywhere](https://docs.aws.amazon.com/rolesanywhere/latest/userguide/introduction.html) adalah Layanan AWS yang memungkinkan Anda memperoleh AWS kredensi sementara untuk beban kerja yang berjalan di luar. AWS Ini memungkinkan akses aman ke AWS sumber daya dari lingkungan cloud lokal atau lainnya.
Sebelum Anda dapat mengautentikasi permintaan dengan IAM Roles Anywhere, Anda harus terlebih dahulu mengumpulkan informasi yang diperlukan dan mengunduh alat pembantu [kredenal](https://docs.aws.amazon.com/rolesanywhere/latest/userguide/credential-helper.html). Dengan mengikuti petunjuk [Memulai](https://docs.aws.amazon.com/rolesanywhere/latest/userguide/getting-started.html) di Panduan Pengguna IAM Roles Anywhere, Anda dapat membuat artefak yang diperlukan.
[SDK for Java tidak memiliki penyedia kredensional khusus untuk mengambil kredensil sementara dari IAM Roles Anywhere, tetapi Anda dapat menggunakan alat bantu kredensi bersama dengan salah satu opsi untuk mengambil kredensil dari proses eksternal.](#credentials-process)
### Gunakan `credential_process` pengaturan di profil
Cuplikan berikut dalam file AWS konfigurasi bersama menunjukkan profil bernama `roles_anywhere` yang menggunakan setelan: `credential_process`
```
[profile roles_anywhere]
credential_process = ./aws_signing_helper credential-process \
--certificate /path/to/certificate \
--private-key /path/to/private-key \
--trust-anchor-arn arn:aws:rolesanywhere:region:account:trust-anchor/TA_ID \
--profile-arn arn:aws:rolesanywhere:region:account:profile/PROFILE_ID \
--role-arn arn:aws:iam::account:role/role-name-with-path
```
Anda perlu mengganti teks yang ditampilkan dengan warna merah dengan nilai-nilai Anda setelah Anda mengumpulkan semua artefak. Elemen pertama dalam pengaturan,`aws_signing_helper`, adalah executable dari alat pembantu kredenal dan `credential-process` merupakan perintah.
Saat Anda mengonfigurasi klien layanan untuk menggunakan `roles_anywhere` profil—seperti yang ditunjukkan dalam kode berikut—SDK menyimpan kredensi sementara dan menyegarkannya sebelum kedaluwarsa:
```
S3Client s3Client = S3Client.builder()
.credentialsProvider(ProfileCredentialsProvider.builder()
.profileName("roles_anywhere").build())
.build();
```
### Konfigurasikan `ProcessCredentialsProvider`
Seperti yang ditunjukkan selanjutnya, Anda dapat menggunakan pendekatan kode saja dengan `ProcessCredentialsProvider` alih-alih menggunakan pengaturan profil:
```
ProcessCredentialsProvider processCredentialsProvider = ProcessCredentialsProvider.builder()
.command("""
./aws_signing_helper credential-process \
--certificate /path/to/certificate \
--private-key /path/to/private-key \
--trust-anchor-arn arn:aws:rolesanywhere:region:account:trust-anchor/TA_ID \
--profile-arn arn:aws:rolesanywhere:region:account:profile/PROFILE_ID \
--role-arn arn:aws:iam::account:role/role-name-with-path
""").build();
S3Client s3Client = S3Client.builder()
.credentialsProvider(processCredentialsProvider)
.build();
```
Ganti teks yang ditampilkan dengan warna merah dengan nilai Anda setelah Anda mengumpulkan semua artefak.
# Menyediakan kredensi dalam kode menggunakan AWS SDK for Java 2.x
Jika rantai kredensi default atau penyedia atau rantai penyedia khusus atau khusus tidak berfungsi untuk aplikasi Anda, Anda dapat memberikan kredensi sementara secara langsung dalam kode. Ini bisa berupa kredensil [peran IAM seperti yang [dijelaskan di atas](credentials-temporary.md#credentials-temporary-from-portal) atau kredensil](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtogetcredentials.html) sementara yang diambil dari (). AWS Security Token Service AWS STS Jika Anda mengambil kredensi sementara menggunakan AWS STS, berikan kepada Layanan AWS klien seperti yang ditunjukkan dalam contoh kode berikut.
1. Asumsikan peran dengan menelepon`StsClient.assumeRole()`.
1. Buat [StaticCredentialsProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/auth/credentials/StaticCredentialsProvider.html)objek dan suplai dengan `AwsSessionCredentials` objek.
1. Konfigurasikan pembuat klien layanan dengan `StaticCredentialsProvider` dan bangun klien.
Contoh berikut membuat klien layanan Amazon S3 menggunakan kredenal sementara yang dikembalikan oleh AWS STS untuk peran yang diasumsikan IAM.
```
// The AWS IAM Identity Center identity (user) who executes this method does not have permission to list buckets.
// The identity is configured in the [default] profile.
public static void assumeRole(String roleArn, String roleSessionName) {
// The IAM role represented by the 'roleArn' parameter can be assumed by identities in two different accounts
// and the role permits the user to only list buckets.
// The SDK's default credentials provider chain will find the single sign-on settings in the [default] profile.
// The identity configured with the [default] profile needs permission to call AssumeRole on the STS service.
try {
Credentials tempRoleCredentials;
try (StsClient stsClient = StsClient.create()) {
AssumeRoleRequest roleRequest = AssumeRoleRequest.builder()
.roleArn(roleArn)
.roleSessionName(roleSessionName)
.build();
AssumeRoleResponse roleResponse = stsClient.assumeRole(roleRequest);
tempRoleCredentials = roleResponse.credentials();
}
// Use the following temporary credential items for the S3 client.
String key = tempRoleCredentials.accessKeyId();
String secKey = tempRoleCredentials.secretAccessKey();
String secToken = tempRoleCredentials.sessionToken();
// List all buckets in the account associated with the assumed role
// by using the temporary credentials retrieved by invoking stsClient.assumeRole().
StaticCredentialsProvider staticCredentialsProvider = StaticCredentialsProvider.create(
AwsSessionCredentials.create(key, secKey, secToken));
try (S3Client s3 = S3Client.builder()
.credentialsProvider(staticCredentialsProvider)
.build()) {
List buckets = s3.listBuckets().buckets();
for (Bucket bucket : buckets) {
System.out.println("bucket name: " + bucket.name());
}
}
} catch (StsException | S3Exception e) {
logger.error(e.getMessage());
System.exit(1);
}
}
```
## Set izin
Set izin berikut yang didefinisikan dalam AWS IAM Identity Center memungkinkan identitas (pengguna) untuk melakukan dua operasi berikut
1. `GetObject`Pengoperasian Layanan Penyimpanan Sederhana Amazon.
1. `AssumeRole`Pengoperasian AWS Security Token Service.
Tanpa mengasumsikan peran, `s3.listBuckets()` metode yang ditunjukkan dalam contoh akan gagal.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"sts:AssumeRole"
],
"Resource": [
"*"
]
}
]
}
```
------
## Asumsi peran
### Kebijakan izin peran yang diasumsikan
Kebijakan izin berikut dilampirkan pada peran yang diasumsikan dalam contoh sebelumnya. Kebijakan izin ini memungkinkan kemampuan untuk mencantumkan semua bucket di akun yang sama dengan peran.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:ListAllMyBuckets"
],
"Resource": [
"*"
]
}
]
}
```
------
### Kebijakan kepercayaan peran yang diasumsikan
Kebijakan kepercayaan berikut dilampirkan pada peran yang diasumsikan dalam contoh sebelumnya. Kebijakan ini memungkinkan peran diasumsikan oleh identitas (pengguna) dalam dua akun.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": [
"arn:aws:iam::111122223333:root",
"arn:aws:iam::555555555555:root"
]
},
"Action": "sts:AssumeRole",
"Condition": {}
}
]
}
```
------
# Membaca kredensi peran IAM di Amazon EC2 menggunakan SDK for Java 2.x
Anda dapat menggunakan peran IAM untuk mengelola kredensional sementara untuk aplikasi yang berjalan pada instans EC2 dan membuat AWS CLI atau permintaan API. AWS Cara ini lebih dianjurkan daripada menyimpan kunci akses dalam instans EC2. Untuk menetapkan AWS peran ke instans EC2 dan membuatnya tersedia untuk semua aplikasinya, Anda membuat profil instance yang dilampirkan ke instance. Profil instans berisi peran dan memungkinkan program yang berjalan di instans EC2 mendapatkan kredensial sementara. Untuk informasi selengkapnya, lihat [Gunakan peran IAM untuk memberikan izin ke aplikasi yang berjalan di instans Amazon EC2](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-ec2.html) dalam *Panduan Pengguna IAM*.
Topik ini memberikan informasi tentang cara mengatur aplikasi Java Anda untuk berjalan pada instans EC2 dan memungkinkan AWS SDK for Java 2.x untuk memperoleh kredensi IAM peran.
## Memperoleh kredensi peran IAM dari lingkungan
Jika aplikasi Anda membuat klien AWS layanan menggunakan metode (atau `create` `builder().build()` metode), SDK for Java menggunakan rantai penyedia *kredensial default*. Rantai penyedia kredensial default mencari lingkungan eksekusi untuk elemen konfigurasi yang dapat diperdagangkan SDK untuk kredenal sementara. [Rantai penyedia kredensi default di AWS SDK for Java 2.x](credentials-chain.md)Bagian ini menjelaskan proses pencarian lengkap.
Langkah terakhir dalam rantai penyedia default hanya tersedia ketika aplikasi Anda berjalan pada sebuah Amazon EC2 instance. Pada langkah ini, SDK menggunakan `InstanceProfileCredentialsProvider` untuk membaca peran IAM yang ditentukan dalam profil instans EC2. SDK kemudian memperoleh kredensi sementara untuk peran IAM tersebut.
Meskipun kredensi ini bersifat sementara dan pada akhirnya akan kedaluwarsa, `InstanceProfileCredentialsProvider` secara berkala menyegarkannya untuk Anda sehingga mereka terus mengizinkan akses ke. AWS
## Memperoleh kredensi peran IAM secara terprogram
Sebagai alternatif dari rantai penyedia kredensial default yang pada akhirnya menggunakan `InstanceProfileCredentialsProvider` on EC2, Anda dapat mengonfigurasi klien layanan secara eksplisit dengan file. `InstanceProfileCredentialsProvider` Pendekatan ini ditunjukkan dalam cuplikan berikut.
```
S3Client s3 = S3Client.builder()
.credentialsProvider(InstanceProfileCredentialsProvider.create())
.build();
```
## Dapatkan kredensi peran IAM dengan aman
Secara default, instans EC2 menjalankan [IMDS](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/configuring-instance-metadata-service.html) (Layanan Metadata Instans) yang memungkinkan SDK mengakses informasi seperti `InstanceProfileCredentialsProvider` peran IAM yang telah dikonfigurasi. Instans EC2 menjalankan dua versi IMDS secara default:
+ Layanan Metadata Instance Versi 1 (IMDSv1) — sebuah metode request/response
+ Instance Metadata Service Version 2 (IMDSv2) — metode berorientasi sesi
[IMDSv2 adalah pendekatan yang lebih aman](https://aws.amazon.com/blogs/security/defense-in-depth-open-firewalls-reverse-proxies-ssrf-vulnerabilities-ec2-instance-metadata-service/) daripada IMDSv1.
Secara default, Java SDK pertama kali mencoba IMDSv2 untuk mendapatkan peran IAM, tetapi jika gagal, ia mencoba. IMDSv1 Namun, karena kurang IMDSv1 aman, AWS merekomendasikan penggunaan IMDSv2 hanya dan untuk menonaktifkan SDK agar tidak mencoba IMDSv1.
Untuk menggunakan pendekatan yang lebih aman, nonaktifkan SDK agar tidak digunakan IMDSv1 dengan memberikan salah satu pengaturan berikut dengan nilai. `true`
+ Variabel lingkungan: `AWS_EC2_METADATA_V1_DISABLED`
+ Properti sistem JVM: aws. `disableEc2MetadataV1`
+ Pengaturan file konfigurasi bersama: `ec2_metadata_v1_disabled`
Dengan salah satu pengaturan ini disetel ke`true`, SDK tidak memuat kredensi peran IMDS dengan menggunakan IMDSv1 jika panggilan awal gagal. IMDSv2