Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Dapatkan rahasia dari AWS Secrets Manager
Secrets Manager menghasilkan entri CloudTrail log saat Anda mengambil rahasia. Untuk informasi selengkapnya, lihat [Log AWS Secrets Manager peristiwa dengan AWS CloudTrail](monitoring-cloudtrail.md).
**Topics**
+ [Java](retrieving-secrets-java.md)
+ [Python](retrieving-secrets-python.md)
+ [.NET](retrieving-secrets-net.md)
+ [Go](retrieving-secrets-go.md)
+ [Karat](retrieving-secrets-rust.md)
+ [Amazon EKS](integrate_eks.md)
+ [AWS Lambda](retrieving-secrets_lambda.md)
+ [Agen Secrets Manager](secrets-manager-agent.md)
+ [C\$1\$1](retrieving-secrets-cpp.md)
+ [JavaScript](retrieving-secrets-javascript.md)
+ [Kotlin](retrieving-secrets-kotlin.md)
+ [PHP](retrieving-secrets-php.md)
+ [Ruby](retrieving-secrets-ruby.md)
+ [AWS CLI](retrieving-secrets_cli.md)
+ [AWS konsol](retrieving-secrets-console.md)
+ [AWS Batch](integrating_BATCH.md)
+ [CloudFormation](cfn-example_reference-secret.md)
+ [GitHub Lowongan](retrieving-secrets_github.md)
+ [GitLab](integrating_gitlab.md)
+ [AWS IoT Greengrass](integrating-greengrass.md)
+ [Penyimpanan Parameter](integrating_parameterstore.md)
# Dapatkan nilai rahasia Secrets Manager menggunakan Java
Dalam aplikasi, Anda dapat mengambil rahasia Anda dengan menelepon `GetSecretValue` atau `BatchGetSecretValue` di salah satu file. AWS SDKs Namun, kami menyarankan Anda menyimpan nilai rahasia Anda dengan menggunakan caching sisi klien. Rahasia caching meningkatkan kecepatan dan mengurangi biaya Anda.
Untuk terhubung ke database menggunakan kredensyal secara rahasia, Anda dapat menggunakan driver Secrets Manager SQL Connection, yang membungkus driver JDBC dasar. Ini juga menggunakan caching sisi klien, sehingga dapat mengurangi biaya untuk memanggil Secrets Manager. APIs
**Topics**
+ [Dapatkan nilai rahasia Secrets Manager menggunakan Java dengan caching sisi klien](retrieving-secrets_cache-java.md)
+ [Connect ke database SQL menggunakan JDBC dengan kredensi dalam rahasia AWS Secrets Manager](retrieving-secrets_jdbc.md)
+ [Dapatkan nilai rahasia Secrets Manager menggunakan Java AWS SDK](retrieving-secrets-java-sdk.md)
# Dapatkan nilai rahasia Secrets Manager menggunakan Java dengan caching sisi klien
Ketika Anda mengambil rahasia, Anda dapat menggunakan Secrets Manager komponen caching berbasis Java untuk cache untuk digunakan di masa mendatang. Mengambil rahasia yang di-cache lebih cepat daripada mengambilnya dari Secrets Manager. Karena ada biaya untuk memanggil Secrets Manager APIs, menggunakan cache dapat mengurangi biaya Anda. Untuk semua cara Anda dapat mengambil rahasia, lihat[Dapatkan rahasia](retrieving-secrets.md).
Kebijakan cache adalah Least Recently Used (LRU), jadi ketika cache harus membuang rahasia, ia membuang rahasia yang paling jarang digunakan. Secara default, cache menyegarkan rahasia setiap jam. Anda dapat mengonfigurasi [seberapa sering rahasia disegarkan](retrieving-secrets_cache-java-ref_SecretCacheConfiguration.md#retrieving-secrets_cache-java-ref_SecretCacheConfiguration_methods-getCacheItemTTL) dalam cache, dan Anda dapat [menghubungkan ke pengambilan rahasia](retrieving-secrets_cache-java-ref_SecretCacheHook.md) untuk menambahkan lebih banyak fungsionalitas.
Cache tidak memaksa pengumpulan sampah setelah referensi cache dibebaskan. Implementasi cache tidak termasuk pembatalan cache. Implementasi cache difokuskan di sekitar cache itu sendiri, dan tidak dikeraskan atau difokuskan keamanan. Jika Anda memerlukan keamanan tambahan seperti mengenkripsi item dalam cache, gunakan antarmuka dan metode abstrak yang disediakan.
Untuk menggunakan komponen, Anda harus memiliki yang berikut:
+ Java 8 atau lingkungan pengembangan yang lebih tinggi. Lihat [Unduhan Java SE](https://www.oracle.com/technetwork/java/javase/downloads/index.html) di situs web Oracle.
Untuk mengunduh kode sumber, lihat [Secrets Manager komponen klien caching berbasis Java](https://github.com/aws/aws-secretsmanager-caching-java) pada. GitHub
Untuk menambahkan komponen ke proyek Anda, dalam file pom.xml Maven Anda, sertakan dependensi berikut. Untuk informasi lebih lanjut tentang Maven, lihat [Panduan Memulai](https://maven.apache.org/guides/getting-started/index.html) di situs web Apache Maven Project.
```
com.amazonaws.secretsmanager
aws-secretsmanager-caching-java
1.0.2
```
**Izin yang diperlukan:**
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`
Untuk informasi selengkapnya, lihat [Referensi izin](auth-and-access.md#reference_iam-permissions).
**Topics**
+ [SecretCache](retrieving-secrets_cache-java-ref_SecretCache.md)
+ [SecretCacheConfiguration](retrieving-secrets_cache-java-ref_SecretCacheConfiguration.md)
+ [SecretCacheHook](retrieving-secrets_cache-java-ref_SecretCacheHook.md)
**Example Ambil rahasia**
Contoh kode berikut menunjukkan fungsi Lambda yang mengambil string rahasia. Ini mengikuti [praktik terbaik](https://docs.aws.amazon.com/lambda/latest/dg/best-practices.html) untuk membuat instance cache di luar penangan fungsi, sehingga tidak terus memanggil API jika Anda memanggil fungsi Lambda lagi.
```
package com.amazonaws.secretsmanager.caching.examples;
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import com.amazonaws.services.lambda.runtime.LambdaLogger;
import com.amazonaws.secretsmanager.caching.SecretCache;
public class SampleClass implements RequestHandler {
private final SecretCache cache = new SecretCache();
@Override public String handleRequest(String secretId, Context context) {
final String secret = cache.getSecretString(secretId);
// Use the secret, return success;
}
}
```
# SecretCache
Cache dalam memori untuk rahasia yang diminta dari Secrets Manager. Anda menggunakan [getSecretString](#retrieving-secrets_cache-java-ref_SecretCache-methods-getSecretString) atau [getSecretBinary](#retrieving-secrets_cache-java-ref_SecretCache-methods-getSecretBinary) untuk mengambil rahasia dari cache. Anda dapat mengkonfigurasi pengaturan cache dengan meneruskan [SecretCacheConfiguration](retrieving-secrets_cache-java-ref_SecretCacheConfiguration.md) objek di konstruktor.
Untuk informasi selengkapnya, termasuk contoh, lihat[Dapatkan nilai rahasia Secrets Manager menggunakan Java dengan caching sisi klien](retrieving-secrets_cache-java.md).
## Konstruktor
`public SecretCache()`
Konstruktor default untuk `SecretCache` objek.
`public SecretCache(AWSSecretsManagerClientBuilder builder)`
Membangun cache baru menggunakan klien Secrets Manager yang dibuat menggunakan yang disediakan [https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClientBuilder.html](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClientBuilder.html). Gunakan konstruktor ini untuk menyesuaikan klien Secrets Manager, misalnya untuk menggunakan Region atau endpoint tertentu.
`public SecretCache(AWSSecretsManager client)`
Membangun cache rahasia baru menggunakan yang disediakan [https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClient.html](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClient.html). Gunakan konstruktor ini untuk menyesuaikan klien Secrets Manager, misalnya untuk menggunakan Region atau endpoint tertentu.
`public SecretCache(SecretCacheConfiguration config)`
Membangun cache rahasia baru menggunakan yang disediakan`SecretCacheConfiguration`.
## Metode
### getSecretString
`public String getSecretString(final String secretId)`
Mengambil rahasia string dari Secrets Manager. Mengembalikan [https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true](https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true).
### getSecretBinary
`public ByteBuffer getSecretBinary(final String secretId)`
Mengambil rahasia biner dari Secrets Manager. Mengembalikan [https://docs.oracle.com/javase/7/docs/api/java/nio/ByteBuffer.html](https://docs.oracle.com/javase/7/docs/api/java/nio/ByteBuffer.html).
### RefreshNow
`public boolean refreshNow(final String secretId) throws InterruptedException`
Memaksa cache untuk menyegarkan. Mengembalikan `true` jika refresh selesai tanpa kesalahan, jika tidak`false`.
### tutup
`public void close()`
Menutup cache.
# SecretCacheConfiguration
Opsi konfigurasi cache untuk[SecretCache](retrieving-secrets_cache-java-ref_SecretCache.md), seperti ukuran cache maks dan Time to Live (TTL) untuk rahasia cache.
## Konstruktor
`public SecretCacheConfiguration`
Konstruktor default untuk `SecretCacheConfiguration` objek.
## Metode
### getClient
`public AWSSecretsManager getClient()`
Mengembalikan [https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClient.html](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClient.html)bahwa cache mengambil rahasia dari.
### SetClient
`public void setClient(AWSSecretsManager client)`
Menetapkan [https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClient.html](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClient.html)klien tempat cache mengambil rahasia dari.
### getCacheHook
`public SecretCacheHook getCacheHook()`
Mengembalikan [SecretCacheHook](retrieving-secrets_cache-java-ref_SecretCacheHook.md) antarmuka yang digunakan untuk mengaitkan pembaruan cache.
### setCacheHook
`public void setCacheHook(SecretCacheHook cacheHook)`
Mengatur [SecretCacheHook](retrieving-secrets_cache-java-ref_SecretCacheHook.md) antarmuka yang digunakan untuk mengaitkan pembaruan cache.
### getMaxCacheUkuran
`public int getMaxCacheSize()`
Mengembalikan ukuran cache maksimum. Defaultnya adalah 1024 rahasia.
### setMaxCacheUkuran
`public void setMaxCacheSize(int maxCacheSize)`
Menetapkan ukuran cache maksimum. Defaultnya adalah 1024 rahasia.
### getCacheItemTTL
`public long getCacheItemTTL()`
Mengembalikan TTL dalam milidetik untuk item cache. Ketika rahasia yang di-cache melebihi TTL ini, cache mengambil salinan rahasia baru dari file. [https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClient.html](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClient.html) Defaultnya adalah 1 jam dalam milidetik.
Cache menyegarkan rahasia secara serempak ketika rahasia diminta setelah TTL. Jika penyegaran sinkron gagal, cache mengembalikan rahasia basi.
### setCacheItemTTL
`public void setCacheItemTTL(long cacheItemTTL)`
Mengatur TTL dalam milidetik untuk item yang di-cache. Ketika rahasia yang di-cache melebihi TTL ini, cache mengambil salinan rahasia baru dari file. [https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClient.html](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClient.html) Defaultnya adalah 1 jam dalam milidetik.
### getVersionStage
`public String getVersionStage()`
Mengembalikan versi rahasia yang ingin Anda cache. Untuk informasi selengkapnya, lihat [Versi rahasia](whats-in-a-secret.md#term_version). Defaultnya adalah` "AWSCURRENT"`.
### setVersionStage
`public void setVersionStage(String versionStage)`
Menetapkan versi rahasia yang ingin Anda cache. Untuk informasi selengkapnya, lihat [Versi rahasia](whats-in-a-secret.md#term_version). Nilai default-nya `"AWSCURRENT"`.
### SecretCacheConfiguration denganKlien
`public SecretCacheConfiguration withClient(AWSSecretsManager client)`
Menetapkan [https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClient.html](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClient.html)untuk mengambil rahasia dari. Mengembalikan `SecretCacheConfiguration` objek diperbarui dengan pengaturan baru.
### SecretCacheConfiguration withCacheHook
`public SecretCacheConfiguration withCacheHook(SecretCacheHook cacheHook)`
Mengatur antarmuka yang digunakan untuk mengaitkan cache dalam memori. Mengembalikan `SecretCacheConfiguration` objek diperbarui dengan pengaturan baru.
### SecretCacheConfiguration withMaxCacheUkuran
`public SecretCacheConfiguration withMaxCacheSize(int maxCacheSize)`
Menetapkan ukuran cache maksimum. Mengembalikan `SecretCacheConfiguration` objek diperbarui dengan pengaturan baru.
### SecretCacheConfiguration withCacheItemTTL
`public SecretCacheConfiguration withCacheItemTTL(long cacheItemTTL)`
Mengatur TTL dalam milidetik untuk item yang di-cache. Ketika rahasia yang di-cache melebihi TTL ini, cache mengambil salinan rahasia baru dari file. [https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClient.html](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClient.html) Defaultnya adalah 1 jam dalam milidetik. Mengembalikan `SecretCacheConfiguration` objek diperbarui dengan pengaturan baru.
### SecretCacheConfiguration withVersionStage
`public SecretCacheConfiguration withVersionStage(String versionStage)`
Menetapkan versi rahasia yang ingin Anda cache. Untuk informasi selengkapnya, lihat [Versi rahasia](whats-in-a-secret.md#term_version). Mengembalikan `SecretCacheConfiguration` objek diperbarui dengan pengaturan baru.
# SecretCacheHook
Antarmuka untuk menghubungkan [SecretCache](retrieving-secrets_cache-java-ref_SecretCache.md) ke dalam untuk melakukan tindakan pada rahasia yang disimpan dalam cache.
## menempatkan
`Object put(final Object o)`
Siapkan objek untuk disimpan dalam cache.
Mengembalikan objek untuk menyimpan dalam cache.
## memperoleh
`Object get(final Object cachedObject)`
Turunkan objek dari objek yang di-cache.
Mengembalikan objek untuk kembali dari cache
# Connect ke database SQL menggunakan JDBC dengan kredensi dalam rahasia AWS Secrets Manager
Dalam aplikasi Java, Anda dapat menggunakan driver Secrets Manager SQL Connection untuk terhubung ke MySQL, PostgreSQL, MSSQLServer Oracle,, Db2, dan database Redshift menggunakan kredensil yang disimpan di Secrets Manager. Setiap driver membungkus driver JDBC dasar, sehingga Anda dapat menggunakan panggilan JDBC untuk mengakses database Anda. Namun, alih-alih memberikan nama pengguna dan kata sandi untuk koneksi, Anda memberikan ID rahasia. Pengemudi memanggil Secrets Manager untuk mengambil nilai rahasia, dan kemudian menggunakan kredensil dalam rahasia untuk terhubung ke database. Driver juga menyimpan kredensialnya menggunakan [pustaka caching sisi klien Java](retrieving-secrets_cache-java.md), sehingga koneksi future tidak memerlukan panggilan ke Secrets Manager. Secara default, cache diperbarui setiap jam dan juga ketika rahasia diputar. Untuk mengkonfigurasi cache, lihat[SecretCacheConfiguration](retrieving-secrets_cache-java-ref_SecretCacheConfiguration.md).
Anda dapat mengunduh kode sumber dari [GitHub](https://github.com/aws/aws-secretsmanager-jdbc ).
Untuk menggunakan driver Secrets Manager SQL Connection:
+ Aplikasi Anda harus di Java 8 atau lebih tinggi.
+ Rahasia Anda harus salah satu dari yang berikut:
+ Sebuah [rahasia database dalam struktur JSON diharapkan](reference_secret_json_structure.md). Untuk memeriksa format, di konsol Secrets Manager, lihat rahasia Anda dan pilih **Ambil nilai rahasia**. Atau, dalam AWS CLI, panggilan [get-secret-value](https://docs.aws.amazon.com/cli/latest/reference/secretsmanager/get-secret-value.html).
+ [Rahasia yang dikelola](integrating_how-services-use-secrets_RDS.md) Amazon RDS. Untuk jenis rahasia ini, Anda harus menentukan titik akhir dan port saat Anda membuat koneksi.
+ Rahasia yang [dikelola](integrating_how-services-use-secrets_RS.md) Amazon Redshift. Untuk jenis rahasia ini, Anda harus menentukan titik akhir dan port saat Anda membuat koneksi.
Jika database Anda direplikasi ke Wilayah lain, untuk menyambung ke database replika di Wilayah lain, Anda menentukan titik akhir dan port regional saat Anda membuat koneksi. Anda dapat menyimpan informasi koneksi regional secara rahasia sebagai key/value pasangan tambahan, dalam parameter Penyimpanan Parameter SSM, atau dalam konfigurasi kode Anda.
Untuk menambahkan driver ke proyek Anda, dalam file build Maven Anda`pom.xml`, tambahkan dependensi berikut untuk driver. Untuk informasi selengkapnya, lihat [Secrets Manager SQL Connection Library](https://search.maven.org/artifact/com.amazonaws.secretsmanager/aws-secretsmanager-jdbc) di situs web Maven Central Repository.
```
com.amazonaws.secretsmanager
aws-secretsmanager-jdbc
1.0.12
```
Pengemudi menggunakan [https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/credentials.html](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/credentials.html). Jika Anda menjalankan driver di Amazon EKS, itu mungkin mengambil kredensil node yang dijalankannya alih-alih peran akun layanan. Untuk mengatasinya, tambahkan versi 1 `com.amazonaws:aws-java-sdk-sts` ke file proyek Gradle atau Maven Anda sebagai dependensi.
Untuk menyetel URL endpoint AWS PrivateLink DNS dan wilayah dalam file: `secretsmanager.properties`
```
drivers.vpcEndpointUrl = endpoint URL
drivers.vpcEndpointRegion = endpoint region
```
Untuk mengganti wilayah primer, atur variabel `AWS_SECRET_JDBC_REGION` lingkungan atau buat perubahan berikut ke `secretsmanager.properties` file:
```
drivers.region = region
```
**Izin yang diperlukan:**
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`
Untuk informasi selengkapnya, lihat [Referensi izin](auth-and-access.md#reference_iam-permissions).
**Topics**
+ [Membangun koneksi ke database](#retrieving-secrets_jdbc_example)
+ [Buat koneksi dengan menentukan titik akhir dan port](#retrieving-secrets_jdbc_example_replica)
+ [Gunakan penyatuan koneksi c3p0 untuk membuat koneksi](#retrieving-secrets_jdbc_example_c3po)
+ [Gunakan penyatuan koneksi c3p0 untuk membuat koneksi dengan menentukan titik akhir dan port](#retrieving-secrets_jdbc_example_c3p0_replica)
## Membangun koneksi ke database
Contoh berikut menunjukkan cara membuat koneksi ke database menggunakan kredensil dan informasi koneksi secara rahasia. Setelah Anda memiliki koneksi, Anda dapat menggunakan panggilan JDBC untuk mengakses database. Untuk informasi selengkapnya, lihat [JDBC Basics](https://docs.oracle.com/javase/tutorial/jdbc/basics/index.html) di situs web dokumentasi Java.
------
#### [ MySQL ]
```
// Load the JDBC driver
Class.forName( "com.amazonaws.secretsmanager.sql.AWSSecretsManagerMySQLDriver" ).newInstance();
// Retrieve the connection info from the secret using the secret ARN
String URL = "secretId";
// Populate the user property with the secret ARN to retrieve user and password from the secret
Properties info = new Properties( );
info.put( "user", "secretId" );
// Establish the connection
conn = DriverManager.getConnection(URL, info);
```
------
#### [ PostgreSQL ]
```
// Load the JDBC driver
Class.forName( "com.amazonaws.secretsmanager.sql.AWSSecretsManagerPostgreSQLDriver" ).newInstance();
// Retrieve the connection info from the secret using the secret ARN
String URL = "secretId";
// Populate the user property with the secret ARN to retrieve user and password from the secret
Properties info = new Properties( );
info.put( "user", "secretId" );
// Establish the connection
conn = DriverManager.getConnection(URL, info);
```
------
#### [ Oracle ]
```
// Load the JDBC driver
Class.forName( "com.amazonaws.secretsmanager.sql.AWSSecretsManagerOracleDriver" ).newInstance();
// Retrieve the connection info from the secret using the secret ARN
String URL = "secretId";
// Populate the user property with the secret ARN to retrieve user and password from the secret
Properties info = new Properties( );
info.put( "user", "secretId" );
// Establish the connection
conn = DriverManager.getConnection(URL, info);
```
------
#### [ MSSQLServer ]
```
// Load the JDBC driver
Class.forName( "com.amazonaws.secretsmanager.sql.AWSSecretsManagerMSSQLServerDriver" ).newInstance();
// Retrieve the connection info from the secret using the secret ARN
String URL = "secretId";
// Populate the user property with the secret ARN to retrieve user and password from the secret
Properties info = new Properties( );
info.put( "user", "secretId" );
// Establish the connection
conn = DriverManager.getConnection(URL, info);
```
------
#### [ Db2 ]
```
// Load the JDBC driver
Class.forName( "com.amazonaws.secretsmanager.sql.AWSSecretsManagerDb2Driver" ).newInstance();
// Retrieve the connection info from the secret using the secret ARN
String URL = "secretId";
// Populate the user property with the secret ARN to retrieve user and password from the secret
Properties info = new Properties( );
info.put( "user", "secretId" );
// Establish the connection
conn = DriverManager.getConnection(URL, info);
```
------
#### [ Redshift ]
```
// Load the JDBC driver
Class.forName( "com.amazonaws.secretsmanager.sql.AWSSecretsManagerRedshiftDriver" ).newInstance();
// Retrieve the connection info from the secret using the secret ARN
String URL = "secretId";
// Populate the user property with the secret ARN to retrieve user and password from the secret
Properties info = new Properties( );
info.put( "user", "secretId" );
// Establish the connection
conn = DriverManager.getConnection(URL, info);
```
------
## Buat koneksi dengan menentukan titik akhir dan port
Contoh berikut menunjukkan cara membuat koneksi ke database menggunakan kredensil secara rahasia dengan titik akhir dan port yang Anda tentukan.
[Rahasia terkelola Amazon RDS](integrating_how-services-use-secrets_RDS.md) tidak menyertakan titik akhir dan port database. Untuk menyambung ke database menggunakan kredensi master dalam rahasia yang dikelola oleh Amazon RDS, Anda menentukannya dalam kode Anda.
[Rahasia yang direplikasi ke Wilayah lain](replicate-secrets.md) dapat meningkatkan latensi untuk koneksi ke database regional, tetapi mereka tidak mengandung informasi koneksi yang berbeda dari rahasia sumber. Setiap replika adalah salinan rahasia sumber. Untuk menyimpan informasi koneksi regional secara rahasia, tambahkan lebih banyak key/value pasangan untuk titik akhir dan informasi port untuk Wilayah.
Setelah Anda memiliki koneksi, Anda dapat menggunakan panggilan JDBC untuk mengakses database. Untuk informasi selengkapnya, lihat [JDBC Basics](https://docs.oracle.com/javase/tutorial/jdbc/basics/index.html) di situs web dokumentasi Java.
------
#### [ MySQL ]
```
// Load the JDBC driver
Class.forName( "com.amazonaws.secretsmanager.sql.AWSSecretsManagerMySQLDriver" ).newInstance();
// Set the endpoint and port. You can also retrieve it from a key/value pair in the secret.
String URL = "jdbc-secretsmanager:mysql://example.com:3306";
// Populate the user property with the secret ARN to retrieve user and password from the secret
Properties info = new Properties( );
info.put( "user", "secretId" );
// Establish the connection
conn = DriverManager.getConnection(URL, info);
```
------
#### [ PostgreSQL ]
```
// Load the JDBC driver
Class.forName( "com.amazonaws.secretsmanager.sql.AWSSecretsManagerPostgreSQLDriver" ).newInstance();
// Set the endpoint and port. You can also retrieve it from a key/value pair in the secret.
String URL = "jdbc-secretsmanager:postgresql://example.com:5432/database";
// Populate the user property with the secret ARN to retrieve user and password from the secret
Properties info = new Properties( );
info.put( "user", "secretId" );
// Establish the connection
conn = DriverManager.getConnection(URL, info);
```
------
#### [ Oracle ]
```
// Load the JDBC driver
Class.forName( "com.amazonaws.secretsmanager.sql.AWSSecretsManagerOracleDriver" ).newInstance();
// Set the endpoint and port. You can also retrieve it from a key/value pair in the secret.
String URL = "jdbc-secretsmanager:oracle:thin:@example.com:1521/ORCL";
// Populate the user property with the secret ARN to retrieve user and password from the secret
Properties info = new Properties( );
info.put( "user", "secretId" );
// Establish the connection
conn = DriverManager.getConnection(URL, info);
```
------
#### [ MSSQLServer ]
```
// Load the JDBC driver
Class.forName( "com.amazonaws.secretsmanager.sql.AWSSecretsManagerMSSQLServerDriver" ).newInstance();
// Set the endpoint and port. You can also retrieve it from a key/value pair in the secret.
String URL = "jdbc-secretsmanager:sqlserver://example.com:1433";
// Populate the user property with the secret ARN to retrieve user and password from the secret
Properties info = new Properties( );
info.put( "user", "secretId" );
// Establish the connection
conn = DriverManager.getConnection(URL, info);
```
------
#### [ Db2 ]
```
// Load the JDBC driver
Class.forName( "com.amazonaws.com.rproxy.goskope.com.amazonaws.secretsmanager.sql.AWSSecretsManagerDb2Driver" ).newInstance();
// Set the endpoint and port. You can also retrieve it from a key/value pair in the secret.
String URL = "jdbc-secretsmanager:db2://example.com:50000";
// Populate the user property with the secret ARN to retrieve user and password from the secret
Properties info = new Properties( );
info.put( "user", "secretId" );
// Establish the connection
conn = DriverManager.getConnection(URL, info);
```
------
#### [ Redshift ]
```
// Load the JDBC driver
Class.forName( "com.amazonaws.com.rproxy.goskope.com.amazonaws.secretsmanager.sql.AWSSecretsManagerRedshiftDriver" ).newInstance();
// Set the endpoint and port. You can also retrieve it from a key/value pair in the secret.
String URL = "jdbc-secretsmanager:redshift://example.com:5439";
// Populate the user property with the secret ARN to retrieve user and password from the secret
Properties info = new Properties( );
info.put( "user", "secretId" );
// Establish the connection
conn = DriverManager.getConnection(URL, info);
```
------
## Gunakan penyatuan koneksi c3p0 untuk membuat koneksi
Contoh berikut menunjukkan cara membuat kolam koneksi dengan `c3p0.properties` file yang menggunakan driver untuk mengambil kredensi dan informasi koneksi dari rahasia. Untuk `user` dan`jdbcUrl`, masukkan ID rahasia untuk mengkonfigurasi kumpulan koneksi. Kemudian Anda dapat mengambil koneksi dari kolam dan menggunakannya sebagai koneksi database lainnya. Untuk informasi selengkapnya, lihat [JDBC Basics](https://docs.oracle.com/javase/tutorial/jdbc/basics/index.html) di situs web dokumentasi Java.
Untuk informasi lebih lanjut tentang c3p0, lihat [c3p0](https://www.mchange.com/projects/c3p0/) di situs web Machinery For Change.
------
#### [ MySQL ]
```
c3p0.user=secretId
c3p0.driverClass=com.amazonaws.secretsmanager.sql.AWSSecretsManagerMySQLDriver
c3p0.jdbcUrl=secretId
```
------
#### [ PostgreSQL ]
```
c3p0.user=secretId
c3p0.driverClass=com.amazonaws.secretsmanager.sql.AWSSecretsManagerPostgreSQLDriver
c3p0.jdbcUrl=secretId
```
------
#### [ Oracle ]
```
c3p0.user=secretId
c3p0.driverClass=com.amazonaws.secretsmanager.sql.AWSSecretsManagerOracleDriver
c3p0.jdbcUrl=secretId
```
------
#### [ MSSQLServer ]
```
c3p0.user=secretId
c3p0.driverClass=com.amazonaws.secretsmanager.sql.AWSSecretsManagerMSSQLServerDriver
c3p0.jdbcUrl=secretId
```
------
#### [ Db2 ]
```
c3p0.user=secretId
c3p0.driverClass=com.amazonaws.secretsmanager.sql.AWSSecretsManagerDb2Driver
c3p0.jdbcUrl=secretId
```
------
#### [ Redshift ]
```
c3p0.user=secretId
c3p0.driverClass=com.amazonaws.secretsmanager.sql.AWSSecretsManagerRedshiftDriver
c3p0.jdbcUrl=secretId
```
------
## Gunakan penyatuan koneksi c3p0 untuk membuat koneksi dengan menentukan titik akhir dan port
Contoh berikut menunjukkan cara membuat kumpulan koneksi dengan `c3p0.properties` file yang menggunakan driver untuk mengambil kredensil secara rahasia dengan titik akhir dan port yang Anda tentukan. Kemudian Anda dapat mengambil koneksi dari kolam dan menggunakannya sebagai koneksi database lainnya. Untuk informasi selengkapnya, lihat [JDBC Basics](https://docs.oracle.com/javase/tutorial/jdbc/basics/index.html) di situs web dokumentasi Java.
[Rahasia terkelola Amazon RDS](integrating_how-services-use-secrets_RDS.md) tidak menyertakan titik akhir dan port database. Untuk menyambung ke database menggunakan kredensi master dalam rahasia yang dikelola oleh Amazon RDS, Anda menentukannya dalam kode Anda.
[Rahasia yang direplikasi ke Wilayah lain](replicate-secrets.md) dapat meningkatkan latensi untuk koneksi ke database regional, tetapi mereka tidak mengandung informasi koneksi yang berbeda dari rahasia sumber. Setiap replika adalah salinan rahasia sumber. Untuk menyimpan informasi koneksi regional secara rahasia, tambahkan lebih banyak key/value pasangan untuk titik akhir dan informasi port untuk Wilayah.
------
#### [ MySQL ]
```
c3p0.user=secretId
c3p0.driverClass=com.amazonaws.secretsmanager.sql.AWSSecretsManagerMySQLDriver
c3p0.jdbcUrl=jdbc-secretsmanager:mysql://example.com:3306
```
------
#### [ PostgreSQL ]
```
c3p0.user=secretId
c3p0.driverClass=com.amazonaws.secretsmanager.sql.AWSSecretsManagerPostgreSQLDriver
c3p0.jdbcUrl=jdbc-secretsmanager:postgresql://example.com:5432/database
```
------
#### [ Oracle ]
```
c3p0.user=secretId
c3p0.driverClass=com.amazonaws.secretsmanager.sql.AWSSecretsManagerOracleDriver
c3p0.jdbcUrl=jdbc-secretsmanager:oracle:thin:@example.com:1521/ORCL
```
------
#### [ MSSQLServer ]
```
c3p0.user=secretId
c3p0.driverClass=com.amazonaws.secretsmanager.sql.AWSSecretsManagerMSSQLServerDriver
c3p0.jdbcUrl=jdbc-secretsmanager:sqlserver://example.com:1433
```
------
#### [ Db2 ]
```
c3p0.user=secretId
c3p0.driverClass=com.amazonaws.secretsmanager.sql.AWSSecretsManagerDb2Driver
c3p0.jdbcUrl=jdbc-secretsmanager:db2://example.com:50000
```
------
#### [ Redshift ]
```
c3p0.user=secretId
c3p0.driverClass=com.amazonaws.secretsmanager.sql.AWSSecretsManagerRedshiftDriver
c3p0.jdbcUrl=jdbc-secretsmanager:redshift://example.com:5439
```
------
# Dapatkan nilai rahasia Secrets Manager menggunakan Java AWS SDK
Dalam aplikasi, Anda dapat mengambil rahasia Anda dengan menelepon `GetSecretValue` atau `BatchGetSecretValue` di salah satu file. AWS SDKs Namun, kami menyarankan Anda menyimpan nilai rahasia Anda dengan menggunakan caching sisi klien. Rahasia caching meningkatkan kecepatan dan mengurangi biaya Anda.
+ Jika Anda menyimpan kredensyal database dalam rahasia, gunakan [driver koneksi SQL Secrets Manager](retrieving-secrets_jdbc.md) untuk terhubung ke database menggunakan kredensyal dalam rahasia.
+ Untuk jenis rahasia lainnya, gunakan [komponen caching berbasis Java Secrets Manager](retrieving-secrets_cache-java.md) atau panggil SDK secara langsung dengan atau. [https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/model/GetSecretValueResult.html](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/model/GetSecretValueResult.html)
Contoh kode berikut menunjukkan cara menggunakan`GetSecretValue`.
**Izin yang diperlukan:** `secretsmanager:GetSecretValue`
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.secretsmanager.SecretsManagerClient;
import software.amazon.awssdk.services.secretsmanager.model.GetSecretValueRequest;
import software.amazon.awssdk.services.secretsmanager.model.GetSecretValueResponse;
import software.amazon.awssdk.services.secretsmanager.model.SecretsManagerException;
/**
* Before running this Java V2 code example, set up your development
* environment, including your credentials.
*
* For more information, see the following documentation topic:
*
* https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
*
* We recommend that you cache your secret values by using client-side caching.
*
* Caching secrets improves speed and reduces your costs. For more information,
* see the following documentation topic:
*
* https://docs.aws.amazon.com/secretsmanager/latest/userguide/retrieving-secrets.html
*/
public class GetSecretValue {
public static void main(String[] args) {
final String usage = """
Usage:
\s
Where:
secretName - The name of the secret (for example, tutorials/MyFirstSecret).\s
""";
if (args.length != 1) {
System.out.println(usage);
System.exit(1);
}
String secretName = args[0];
Region region = Region.US_EAST_1;
SecretsManagerClient secretsClient = SecretsManagerClient.builder()
.region(region)
.build();
getValue(secretsClient, secretName);
secretsClient.close();
}
public static void getValue(SecretsManagerClient secretsClient, String secretName) {
try {
GetSecretValueRequest valueRequest = GetSecretValueRequest.builder()
.secretId(secretName)
.build();
GetSecretValueResponse valueResponse = secretsClient.getSecretValue(valueRequest);
String secret = valueResponse.secretString();
System.out.println(secret);
} catch (SecretsManagerException e) {
System.err.println(e.awsErrorDetails().errorMessage());
System.exit(1);
}
}
}
```
# Dapatkan nilai rahasia Secrets Manager menggunakan Python
Dalam aplikasi, Anda dapat mengambil rahasia Anda dengan menelepon `GetSecretValue` atau `BatchGetSecretValue` di salah satu file. AWS SDKs Namun, kami menyarankan Anda menyimpan nilai rahasia Anda dengan menggunakan caching sisi klien. Rahasia caching meningkatkan kecepatan dan mengurangi biaya Anda.
**Topics**
+ [Dapatkan nilai rahasia Secrets Manager menggunakan Python dengan caching sisi klien](retrieving-secrets_cache-python.md)
+ [Dapatkan nilai rahasia Secrets Manager menggunakan Python AWS SDK](retrieving-secrets-python-sdk.md)
+ [Dapatkan sejumlah nilai rahasia Secrets Manager menggunakan Python AWS SDK](retrieving-secrets-python-batch.md)
# Dapatkan nilai rahasia Secrets Manager menggunakan Python dengan caching sisi klien
Saat Anda mengambil rahasia, Anda dapat menggunakan komponen caching berbasis Secrets Manager Python untuk men-cache untuk digunakan di masa mendatang. Mengambil rahasia yang di-cache lebih cepat daripada mengambilnya dari Secrets Manager. Karena ada biaya untuk memanggil Secrets Manager APIs, menggunakan cache dapat mengurangi biaya Anda. Untuk semua cara Anda dapat mengambil rahasia, lihat[Dapatkan rahasia](retrieving-secrets.md).
Kebijakan cache adalah Least Recently Used (LRU), jadi ketika cache harus membuang rahasia, ia membuang rahasia yang paling jarang digunakan. Secara default, cache menyegarkan rahasia setiap jam. Anda dapat mengonfigurasi [seberapa sering rahasia disegarkan](retrieving-secrets_cache-ref-secretcacheconfig.md) dalam cache, dan Anda dapat [menghubungkan ke pengambilan rahasia](retrieving-secrets_cache-ref-secretcachehook.md) untuk menambahkan lebih banyak fungsionalitas.
Cache tidak memaksa pengumpulan sampah setelah referensi cache dibebaskan. Implementasi cache tidak termasuk pembatalan cache. Implementasi cache difokuskan di sekitar cache itu sendiri, dan tidak dikeraskan atau difokuskan keamanan. Jika Anda memerlukan keamanan tambahan seperti mengenkripsi item dalam cache, gunakan antarmuka dan metode abstrak yang disediakan.
Untuk menggunakan komponen, Anda harus memiliki yang berikut:
+ Python 3.6 atau yang lebih baru.
+ botocore 1.12 atau lebih tinggi. [Lihat [AWS SDK untuk Python](https://aws.amazon.com/sdk-for-python/) dan Botocore.](https://botocore.amazonaws.com/v1/documentation/api/latest/index.html)
+ setuptools\$1scm 3.2 atau lebih tinggi. Lihat [https://pypi. org/project/setuptools-scm/](https://pypi.org/project/setuptools-scm/).
Untuk mengunduh kode sumber, lihat [Secrets Manager Python berbasis komponen klien caching](https://github.com/aws/aws-secretsmanager-caching-python ) di. GitHub
Untuk menginstal komponen, gunakan perintah berikut.
```
$ pip install aws-secretsmanager-caching
```
**Izin yang diperlukan:**
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`
Untuk informasi selengkapnya, lihat [Referensi izin](auth-and-access.md#reference_iam-permissions).
**Topics**
+ [SecretCache](retrieving-secrets_cache-ref-secretcache.md)
+ [SecretCacheConfig](retrieving-secrets_cache-ref-secretcacheconfig.md)
+ [SecretCacheHook](retrieving-secrets_cache-ref-secretcachehook.md)
+ [@InjectSecretString](retrieving-secrets_cache-decor-string.md)
+ [@InjectKeywordedSecretString](retrieving-secrets_cache-decor-keyword.md)
**Example Ambil rahasia**
Contoh berikut menunjukkan bagaimana untuk mendapatkan nilai rahasia untuk rahasia bernama*mysecret*.
```
import botocore
import botocore.session
from aws_secretsmanager_caching import SecretCache, SecretCacheConfig
client = botocore.session.get_session().create_client('secretsmanager')
cache_config = SecretCacheConfig()
cache = SecretCache( config = cache_config, client = client)
secret = cache.get_secret_string('mysecret')
```
# SecretCache
Cache dalam memori untuk rahasia yang diambil dari Secrets Manager. Anda menggunakan [get\$1secret\$1string](#retrieving-secrets_cache-ref-secretcache_get_secret_string) atau [get\$1secret\$1binary](#retrieving-secrets_cache-ref-secretcache_get_secret_binary) untuk mengambil rahasia dari cache. Anda dapat mengkonfigurasi pengaturan cache dengan meneruskan [SecretCacheConfig](retrieving-secrets_cache-ref-secretcacheconfig.md) objek di konstruktor.
Untuk informasi selengkapnya, termasuk contoh, lihat[Dapatkan nilai rahasia Secrets Manager menggunakan Python dengan caching sisi klien](retrieving-secrets_cache-python.md).
```
cache = SecretCache(
config = SecretCacheConfig,
client = [client](https://botocore.amazonaws.com/v1/documentation/api/latest/reference/services/secretsmanager.html)
)
```
**Topics**
+ [get\$1secret\$1string](#retrieving-secrets_cache-ref-secretcache_get_secret_string)
+ [get\$1secret\$1binary](#retrieving-secrets_cache-ref-secretcache_get_secret_binary)
## get\$1secret\$1string
Mengambil nilai string rahasia.
Sintaksis Permintaan
```
response = cache.get_secret_string(
secret_id='string',
version_stage='string' )
```
Parameter
+ `secret_id`(*string*): [Diperlukan] Nama atau ARN rahasia.
+ `version_stage`(*string*): Versi rahasia yang ingin Anda ambil. Untuk informasi selengkapnya, lihat [versi rahasia](whats-in-a-secret.md). Defaultnya adalah 'AWSCURRENT'.
Jenis pengembalian
string
## get\$1secret\$1binary
Mengambil nilai biner rahasia.
Sintaksis Permintaan
```
response = cache.get_secret_binary(
secret_id='string',
version_stage='string'
)
```
Parameter
+ `secret_id`(*string*): [Diperlukan] Nama atau ARN rahasia.
+ `version_stage`(*string*): Versi rahasia yang ingin Anda ambil. Untuk informasi selengkapnya, lihat [versi rahasia](whats-in-a-secret.md). Defaultnya adalah 'AWSCURRENT'.
Jenis pengembalian
string yang dikodekan [base64](https://tools.ietf.org/html/rfc4648#section-4)
# SecretCacheConfig
Opsi konfigurasi cache untuk ukuran cache maks dan Time to Live (TTL) untuk rahasia cache. [SecretCache](retrieving-secrets_cache-ref-secretcache.md)Parameter
`max_cache_size`(*int*)
Ukuran cache maksimum. Defaultnya adalah `1024` rahasia.
`exception_retry_delay_base`(*int*)
Jumlah detik untuk menunggu setelah pengecualian ditemui sebelum mencoba kembali permintaan. Nilai default-nya `1`.
`exception_retry_growth_factor`(*int*) pur
Faktor pertumbuhan yang digunakan untuk menghitung waktu tunggu antara percobaan ulang permintaan yang gagal. Nilai default-nya `2`.
`exception_retry_delay_max`(*int*)
Jumlah maksimum waktu dalam hitungan detik untuk menunggu di antara permintaan yang gagal. Nilai default-nya `3600`.
`default_version_stage`(*str)*
Versi rahasia yang ingin Anda cache. Untuk informasi selengkapnya, lihat [Versi rahasia](whats-in-a-secret.md#term_version). Nilai default-nya `'AWSCURRENT'`.
`secret_refresh_interval`(*int*)
Jumlah detik untuk menunggu antara menyegarkan informasi rahasia yang di-cache. Nilai default-nya `3600`.
`secret_cache_hook` (*SecretCacheHook*)
Implementasi dari kelas `SecretCacheHook` abstrak. Nilai default-nya adalah `None`.
# SecretCacheHook
Antarmuka untuk menghubungkan [SecretCache](retrieving-secrets_cache-ref-secretcache.md) ke dalam untuk melakukan tindakan pada rahasia yang disimpan dalam cache.
**Topics**
+ [menempatkan](#retrieving-secrets_cache-ref-secretcachehook_put)
+ [memperoleh](#retrieving-secrets_cache-ref-secretcachehook_get)
## menempatkan
Mempersiapkan objek untuk disimpan dalam cache.
Sintaksis Permintaan
```
response = hook.put(
obj='secret_object'
)
```
Parameter
+ `obj`(*objek*) -- [Diperlukan] Rahasia atau objek yang berisi rahasia.
Jenis pengembalian
object
## memperoleh
Mendapatkan objek dari objek yang di-cache.
Sintaksis Permintaan
```
response = hook.get(
obj='secret_object'
)
```
Parameter
+ `obj`(*objek*): [Wajib] Rahasia atau objek yang berisi rahasia.
Jenis pengembalian
object
# @InjectSecretString
Dekorator ini mengharapkan string ID rahasia dan [SecretCache](retrieving-secrets_cache-ref-secretcache.md) sebagai argumen pertama dan kedua. Dekorator mengembalikan nilai string rahasia. Rahasianya harus berisi string.
```
from aws_secretsmanager_caching import SecretCache
from aws_secretsmanager_caching import InjectKeywordedSecretString, InjectSecretString
cache = SecretCache()
@InjectSecretString ( 'mysecret' , cache )
def function_to_be_decorated( arg1, arg2, arg3):
```
# @InjectKeywordedSecretString
Dekorator ini mengharapkan string ID rahasia dan [SecretCache](retrieving-secrets_cache-ref-secretcache.md) sebagai argumen pertama dan kedua. Argumen yang tersisa memetakan parameter dari fungsi yang dibungkus ke kunci JSON dalam rahasia. Rahasianya harus berisi string dalam struktur JSON.
Untuk rahasia yang berisi JSON ini:
```
{
"username": "saanvi",
"password": "EXAMPLE-PASSWORD"
}
```
Contoh berikut menunjukkan cara mengekstrak nilai JSON untuk `username` dan `password` dari rahasia.
```
from aws_secretsmanager_caching import SecretCache
from aws_secretsmanager_caching import InjectKeywordedSecretString, InjectSecretString
cache = SecretCache()
@InjectKeywordedSecretString ( secret_id = 'mysecret' , cache = cache , func_username = 'username' , func_password = 'password' )
def function_to_be_decorated( func_username, func_password):
print( 'Do something with the func_username and func_password parameters')
```
# Dapatkan nilai rahasia Secrets Manager menggunakan Python AWS SDK
Dalam aplikasi, Anda dapat mengambil rahasia Anda dengan menelepon `GetSecretValue` atau `BatchGetSecretValue` di salah satu file. AWS SDKs Namun, kami menyarankan Anda menyimpan nilai rahasia Anda dengan menggunakan caching sisi klien. Rahasia caching meningkatkan kecepatan dan mengurangi biaya Anda.
Untuk aplikasi Python, gunakan [komponen caching berbasis Secrets Manager Python](retrieving-secrets_cache-python.md) atau panggil SDK langsung dengan atau. [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/secretsmanager/client/get_secret_value.html](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/secretsmanager/client/get_secret_value.html)
Contoh kode berikut menunjukkan cara menggunakan`GetSecretValue`.
**Izin yang diperlukan:** `secretsmanager:GetSecretValue`
```
"""
Purpose
Shows how to use the AWS SDK for Python (Boto3) with AWS
Secrets Manager to get a specific of secrets that match a
specified name
"""
import boto3
import logging
from get_secret_value import GetSecretWrapper
# Configure logging
logging.basicConfig(level=logging.INFO)
def run_scenario(secret_name):
"""
Retrieve a secret from AWS Secrets Manager.
:param secret_name: Name of the secret to retrieve.
:type secret_name: str
"""
try:
# Validate secret_name
if not secret_name:
raise ValueError("Secret name must be provided.")
# Retrieve the secret by name
client = boto3.client("secretsmanager")
wrapper = GetSecretWrapper(client)
secret = wrapper.get_secret(secret_name)
# Note: Secrets should not be logged.
return secret
except Exception as e:
logging.error(f"Error retrieving secret: {e}")
raise
class GetSecretWrapper:
def __init__(self, secretsmanager_client):
self.client = secretsmanager_client
def get_secret(self, secret_name):
"""
Retrieve individual secrets from AWS Secrets Manager using the get_secret_value API.
This function assumes the stack mentioned in the source code README has been successfully deployed.
This stack includes 7 secrets, all of which have names beginning with "mySecret".
:param secret_name: The name of the secret fetched.
:type secret_name: str
"""
try:
get_secret_value_response = self.client.get_secret_value(
SecretId=secret_name
)
logging.info("Secret retrieved successfully.")
return get_secret_value_response["SecretString"]
except self.client.exceptions.ResourceNotFoundException:
msg = f"The requested secret {secret_name} was not found."
logger.info(msg)
return msg
except Exception as e:
logger.error(f"An unknown error occurred: {str(e)}.")
raise
```
# Dapatkan sejumlah nilai rahasia Secrets Manager menggunakan Python AWS SDK
Contoh kode berikut menunjukkan cara mendapatkan sejumlah nilai rahasia Secrets Manager.
**Izin yang diperlukan:**
+ `secretsmanager:BatchGetSecretValue`
+ `secretsmanager:GetSecretValue`izin untuk setiap rahasia yang ingin Anda ambil.
+ Jika Anda menggunakan filter, Anda juga harus memilikinya`secretsmanager:ListSecrets`.
Untuk contoh kebijakan izin, lihat[Contoh: Izin untuk mengambil sekelompok nilai rahasia dalam batch](auth-and-access_iam-policies.md#auth-and-access_examples_batch).
**penting**
Jika Anda memiliki kebijakan VPCE yang menolak izin untuk mengambil rahasia individu dalam grup yang Anda ambil, tidak `BatchGetSecretValue` akan mengembalikan nilai rahasia apa pun, dan itu akan mengembalikan kesalahan.
```
class BatchGetSecretsWrapper:
def __init__(self, secretsmanager_client):
self.client = secretsmanager_client
def batch_get_secrets(self, filter_name):
"""
Retrieve multiple secrets from AWS Secrets Manager using the batch_get_secret_value API.
This function assumes the stack mentioned in the source code README has been successfully deployed.
This stack includes 7 secrets, all of which have names beginning with "mySecret".
:param filter_name: The full or partial name of secrets to be fetched.
:type filter_name: str
"""
try:
secrets = []
response = self.client.batch_get_secret_value(
Filters=[{"Key": "name", "Values": [f"{filter_name}"]}]
)
for secret in response["SecretValues"]:
secrets.append(json.loads(secret["SecretString"]))
if secrets:
logger.info("Secrets retrieved successfully.")
else:
logger.info("Zero secrets returned without error.")
return secrets
except self.client.exceptions.ResourceNotFoundException:
msg = f"One or more requested secrets were not found with filter: {filter_name}"
logger.info(msg)
return msg
except Exception as e:
logger.error(f"An unknown error occurred:\n{str(e)}.")
raise
```
# Dapatkan nilai rahasia Secrets Manager menggunakan .NET
Dalam aplikasi, Anda dapat mengambil rahasia Anda dengan menelepon `GetSecretValue` atau `BatchGetSecretValue` di salah satu file. AWS SDKs Namun, kami menyarankan Anda menyimpan nilai rahasia Anda dengan menggunakan caching sisi klien. Rahasia caching meningkatkan kecepatan dan mengurangi biaya Anda.
**Topics**
+ [Dapatkan nilai rahasia Secrets Manager menggunakan.NET dengan caching sisi klien](retrieving-secrets_cache-net.md)
+ [Dapatkan nilai rahasia Secrets Manager menggunakan SDK untuk .NET](retrieving-secrets-net-sdk.md)
# Dapatkan nilai rahasia Secrets Manager menggunakan.NET dengan caching sisi klien
Saat Anda mengambil rahasia, Anda dapat menggunakan komponen caching berbasis Secrets Manager .net untuk men-cache untuk digunakan di masa mendatang. Mengambil rahasia yang di-cache lebih cepat daripada mengambilnya dari Secrets Manager. Karena ada biaya untuk memanggil Secrets Manager APIs, menggunakan cache dapat mengurangi biaya Anda. Untuk semua cara Anda dapat mengambil rahasia, lihat[Dapatkan rahasia](retrieving-secrets.md).
Kebijakan cache adalah Least Recently Used (LRU), jadi ketika cache harus membuang rahasia, ia membuang rahasia yang paling jarang digunakan. Secara default, cache menyegarkan rahasia setiap jam. Anda dapat mengonfigurasi [seberapa sering rahasia disegarkan](retrieving-secrets_cache-net-SecretCacheConfiguration.md#retrieving-secrets_cache-net-SecretCacheConfiguration-properties_CacheItemTTL) dalam cache, dan Anda dapat [menghubungkan ke pengambilan rahasia](retrieving-secrets_cache-net-ISecretCacheHook.md) untuk menambahkan lebih banyak fungsionalitas.
Cache tidak memaksa pengumpulan sampah setelah referensi cache dibebaskan. Implementasi cache tidak termasuk pembatalan cache. Implementasi cache difokuskan di sekitar cache itu sendiri, dan tidak dikeraskan atau difokuskan keamanan. Jika Anda memerlukan keamanan tambahan seperti mengenkripsi item dalam cache, gunakan antarmuka dan metode abstrak yang disediakan.
Untuk menggunakan komponen, Anda harus memiliki yang berikut:
+ .NET Framework 4.6.2 atau lebih tinggi, atau.NET Standard 2.0 atau lebih tinggi. Lihat [Mengunduh.NET](https://dotnet.microsoft.com/en-us/download) di situs web Microsoft .NET.
+ AWS SDK for .NET. Lihat [AWS SDKs](asm_access.md#asm-sdks).
Untuk mengunduh kode sumber, lihat [Caching client untuk.NET](https://github.com/aws/aws-secretsmanager-caching-net ) di GitHub.
Untuk menggunakan cache, pertama buat instance, lalu ambil rahasia Anda dengan menggunakan atau. `GetSecretString` `GetSecretBinary` Pada pengambilan berturut-turut, cache mengembalikan salinan rahasia yang di-cache.
**Untuk mendapatkan paket caching**
+ Lakukan salah satu tindakan berikut:
+ Jalankan perintah.NET CLI berikut di direktori proyek Anda.
```
dotnet add package AWSSDK.SecretsManager.Caching --version 1.0.6
```
+ Tambahkan referensi paket berikut ke `.csproj` file Anda.
```
```
**Izin yang diperlukan:**
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`
Untuk informasi selengkapnya, lihat [Referensi izin](auth-and-access.md#reference_iam-permissions).
**Topics**
+ [SecretsManagerCache](retrieving-secrets_cache-net-SecretsManagerCache.md)
+ [SecretCacheConfiguration](retrieving-secrets_cache-net-SecretCacheConfiguration.md)
+ [ISecretCacheHook](retrieving-secrets_cache-net-ISecretCacheHook.md)
**Example Ambil rahasia**
Contoh kode berikut menunjukkan metode yang mengambil rahasia bernama*MySecret*.
```
using Amazon.SecretsManager.Extensions.Caching;
namespace LambdaExample
{
public class CachingExample
{
private const string MySecretName ="MySecret";
private SecretsManagerCache cache = new SecretsManagerCache();
public async Task FunctionHandlerAsync(string input, ILambdaContext context)
{
string MySecret = await cache.GetSecretString(MySecretName);
// Use the secret, return success
}
}
}
```
**Example Konfigurasikan durasi penyegaran cache time to live (TTL)**
Contoh kode berikut menunjukkan metode yang mengambil rahasia bernama *MySecret* dan menetapkan durasi penyegaran cache TTL menjadi 24 jam.
```
using Amazon.SecretsManager.Extensions.Caching;
namespace LambdaExample
{
public class CachingExample
{
private const string MySecretName = "MySecret";
private static SecretCacheConfiguration cacheConfiguration = new SecretCacheConfiguration
{
CacheItemTTL = 86400000
};
private SecretsManagerCache cache = new SecretsManagerCache(cacheConfiguration);
public async Task FunctionHandlerAsync(string input, ILambdaContext context)
{
string mySecret = await cache.GetSecretString(MySecretName);
// Use the secret, return success
}
}
}
```
# SecretsManagerCache
Cache dalam memori untuk rahasia yang diminta dari Secrets Manager. Anda menggunakan [GetSecretString](#retrieving-secrets_cache-net-SecretsManagerCache-methods-GetSecretString) atau [GetSecretBinary](#retrieving-secrets_cache-net-SecretsManagerCache-methods-GetSecretBinary) untuk mengambil rahasia dari cache. Anda dapat mengkonfigurasi pengaturan cache dengan meneruskan [SecretCacheConfiguration](retrieving-secrets_cache-net-SecretCacheConfiguration.md) objek di konstruktor.
Untuk informasi selengkapnya, termasuk contoh, lihat[Dapatkan nilai rahasia Secrets Manager menggunakan.NET dengan caching sisi klien](retrieving-secrets_cache-net.md).
## Konstruktor
`public SecretsManagerCache()`
Konstruktor default untuk `SecretsManagerCache` objek.
`public SecretsManagerCache(IAmazonSecretsManager secretsManager)`
Membangun cache baru menggunakan klien Secrets Manager yang dibuat menggunakan yang disediakan [AmazonSecretsManagerClient](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TSecretsManagerClient.html). Gunakan konstruktor ini untuk menyesuaikan klien Secrets Manager, misalnya untuk menggunakan wilayah atau titik akhir tertentu.
**Parameter**
Rahasia Manajer
[AmazonSecretsManagerClient](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TSecretsManagerClient.html)Untuk mengambil rahasia dari.
`public SecretsManagerCache(SecretCacheConfiguration config)`
Membangun cache rahasia baru menggunakan yang disediakan[SecretCacheConfiguration](retrieving-secrets_cache-net-SecretCacheConfiguration.md). Gunakan konstruktor ini untuk mengkonfigurasi cache, misalnya jumlah rahasia untuk cache dan seberapa sering itu menyegarkan.
**Parameter**
config
A [SecretCacheConfiguration](retrieving-secrets_cache-net-SecretCacheConfiguration.md) yang berisi informasi konfigurasi untuk cache.
`public SecretsManagerCache(IAmazonSecretsManager secretsManager, SecretCacheConfiguration config)`
Membangun cache baru menggunakan klien Secrets Manager yang dibuat menggunakan yang disediakan [AmazonSecretsManagerClient](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TSecretsManagerClient.html)dan file. [SecretCacheConfiguration](retrieving-secrets_cache-net-SecretCacheConfiguration.md) Gunakan konstruktor ini untuk menyesuaikan klien Secrets Manager, misalnya untuk menggunakan wilayah atau titik akhir tertentu serta mengkonfigurasi cache, misalnya jumlah rahasia untuk cache dan seberapa sering itu menyegarkan.
**Parameter**
Rahasia Manajer
[AmazonSecretsManagerClient](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TSecretsManagerClient.html)Untuk mengambil rahasia dari.
config
A [SecretCacheConfiguration](retrieving-secrets_cache-net-SecretCacheConfiguration.md) yang berisi informasi konfigurasi untuk cache.
## Metode
### GetSecretString
`public async Task GetSecretString(String secretId)`
Mengambil rahasia string dari Secrets Manager.Parameter
secretId
ARN atau nama rahasia untuk diambil.
### GetSecretBinary
`public async Task GetSecretBinary(String secretId)`
Mengambil rahasia biner dari Secrets Manager.Parameter
secretId
ARN atau nama rahasia untuk diambil.
### RefreshNowAsync
`public async Task RefreshNowAsync(String secretId)`
Meminta nilai rahasia dari Secrets Manager dan memperbarui cache dengan perubahan apa pun. Jika tidak ada entri cache yang ada, buat yang baru. Kembali `true` jika penyegaran berhasil.Parameter
secretId
ARN atau nama rahasia untuk diambil.
### GetCachedSecret
`public SecretCacheItem GetCachedSecret(string secretId)`
Mengembalikan entri cache untuk rahasia tertentu jika ada dalam cache. Jika tidak, mengambil rahasia dari Secrets Manager dan membuat entri cache baru.Parameter
secretId
ARN atau nama rahasia untuk diambil.
# SecretCacheConfiguration
Opsi konfigurasi cache untuk[SecretsManagerCache](retrieving-secrets_cache-net-SecretsManagerCache.md), seperti ukuran cache maksimum dan Time to Live (TTL) untuk rahasia cache.
## Sifat-sifat
### CacheItemTTL
`public uint CacheItemTTL { get; set; }`
TTL dari item cache dalam milidetik. Defaultnya adalah `3600000` ms atau 1 jam. Maksimumnya adalah `4294967295` ms, yaitu sekitar 49,7 hari.
### MaxCacheSize
`public ushort MaxCacheSize { get; set; }`
Ukuran cache maksimum. Defaultnya adalah 1024 rahasia. Maksimum adalah 65.535.
### VersionStage
`public string VersionStage { get; set; }`
Versi rahasia yang ingin Anda cache. Untuk informasi selengkapnya, lihat [Versi rahasia](whats-in-a-secret.md#term_version). Nilai default-nya `"AWSCURRENT"`.
### Klien
`public IAmazonSecretsManager Client { get; set; }`
[AmazonSecretsManagerClient](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TSecretsManagerClient.html)Untuk mengambil rahasia dari. Jika ya`null`, cache membuat instance klien baru. Nilai default-nya `null`.
### CacheHook
`public ISecretCacheHook CacheHook { get; set; }`
A[ISecretCacheHook](retrieving-secrets_cache-net-ISecretCacheHook.md).
# ISecretCacheHook
Antarmuka untuk menghubungkan [SecretsManagerCache](retrieving-secrets_cache-net-SecretsManagerCache.md) ke dalam untuk melakukan tindakan pada rahasia yang disimpan dalam cache.
## Metode
### Masukan
`object Put(object o);`
Siapkan objek untuk disimpan dalam cache.
Mengembalikan objek untuk menyimpan dalam cache.
### Dapatkan
`object Get(object cachedObject);`
Turunkan objek dari objek yang di-cache.
Mengembalikan objek untuk kembali dari cache
# Dapatkan nilai rahasia Secrets Manager menggunakan SDK untuk .NET
Dalam aplikasi, Anda dapat mengambil rahasia Anda dengan menelepon `GetSecretValue` atau `BatchGetSecretValue` di salah satu file. AWS SDKs Namun, kami menyarankan Anda menyimpan nilai rahasia Anda dengan menggunakan caching sisi klien. Rahasia caching meningkatkan kecepatan dan mengurangi biaya Anda.
Untuk aplikasi.NET, gunakan [komponen caching berbasis Secrets Manager .NET](retrieving-secrets_cache-net.md) atau panggil SDK secara langsung dengan atau. [https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TGetSecretValueRequest.html](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TGetSecretValueRequest.html)
Contoh kode berikut menunjukkan cara menggunakan`GetSecretValue`.
**Izin yang diperlukan:** `secretsmanager:GetSecretValue`
```
using System;
using System.IO;
using System.Threading.Tasks;
using Amazon.SecretsManager;
using Amazon.SecretsManager.Model;
///
/// This example uses the Amazon Web Service Secrets Manager to retrieve
/// the secret value for the provided secret name.
///
public class GetSecretValue
{
///
/// The main method initializes the necessary values and then calls
/// the GetSecretAsync and DecodeString methods to get the decoded
/// secret value for the secret named in secretName.
///
public static async Task Main()
{
string secretName = "<<{{MySecretName}}>>";
string secret;
IAmazonSecretsManager client = new AmazonSecretsManagerClient();
var response = await GetSecretAsync(client, secretName);
if (response is not null)
{
secret = DecodeString(response);
if (!string.IsNullOrEmpty(secret))
{
Console.WriteLine($"The decoded secret value is: {secret}.");
}
else
{
Console.WriteLine("No secret value was returned.");
}
}
}
///
/// Retrieves the secret value given the name of the secret to
/// retrieve.
///
/// The client object used to retrieve the secret
/// value for the given secret name.
/// The name of the secret value to retrieve.
/// The GetSecretValueReponse object returned by
/// GetSecretValueAsync.
public static async Task GetSecretAsync(
IAmazonSecretsManager client,
string secretName)
{
GetSecretValueRequest request = new GetSecretValueRequest()
{
SecretId = secretName,
VersionStage = "AWSCURRENT", // VersionStage defaults to AWSCURRENT if unspecified.
};
GetSecretValueResponse response = null;
// For the sake of simplicity, this example handles only the most
// general SecretsManager exception.
try
{
response = await client.GetSecretValueAsync(request);
}
catch (AmazonSecretsManagerException e)
{
Console.WriteLine($"Error: {e.Message}");
}
return response;
}
///
/// Decodes the secret returned by the call to GetSecretValueAsync and
/// returns it to the calling program.
///
/// A GetSecretValueResponse object containing
/// the requested secret value returned by GetSecretValueAsync.
/// A string representing the decoded secret value.
public static string DecodeString(GetSecretValueResponse response)
{
// Decrypts secret using the associated AWS Key Management Service
// Customer Master Key (CMK.) Depending on whether the secret is a
// string or binary value, one of these fields will be populated.
if (response.SecretString is not null)
{
var secret = response.SecretString;
return secret;
}
else if (response.SecretBinary is not null)
{
var memoryStream = response.SecretBinary;
StreamReader reader = new StreamReader(memoryStream);
string decodedBinarySecret = System.Text.Encoding.UTF8.GetString(Convert.FromBase64String(reader.ReadToEnd()));
return decodedBinarySecret;
}
else
{
return string.Empty;
}
}
}
```
# Dapatkan nilai rahasia Secrets Manager menggunakan Go
Dalam aplikasi, Anda dapat mengambil rahasia Anda dengan menelepon `GetSecretValue` atau `BatchGetSecretValue` di salah satu file. AWS SDKs Namun, kami menyarankan Anda menyimpan nilai rahasia Anda dengan menggunakan caching sisi klien. Rahasia caching meningkatkan kecepatan dan mengurangi biaya Anda.
**Topics**
+ [Dapatkan nilai rahasia Secrets Manager menggunakan Go dengan caching sisi klien](retrieving-secrets_cache-go.md)
+ [Dapatkan nilai rahasia Secrets Manager menggunakan Go AWS SDK](retrieving-secrets-go-sdk.md)
# Dapatkan nilai rahasia Secrets Manager menggunakan Go dengan caching sisi klien
Saat Anda mengambil rahasia, Anda dapat menggunakan komponen caching berbasis Secrets Manager Go untuk men-cache untuk digunakan di masa mendatang. Mengambil rahasia yang di-cache lebih cepat daripada mengambilnya dari Secrets Manager. Karena ada biaya untuk memanggil Secrets Manager APIs, menggunakan cache dapat mengurangi biaya Anda. Untuk semua cara Anda dapat mengambil rahasia, lihat[Dapatkan rahasia](retrieving-secrets.md).
Kebijakan cache adalah Least Recently Used (LRU), jadi ketika cache harus membuang rahasia, ia membuang rahasia yang paling jarang digunakan. Secara default, cache menyegarkan rahasia setiap jam. Anda dapat mengonfigurasi [seberapa sering rahasia disegarkan](retrieving-secrets_cache-go_CacheConfig.md) dalam cache, dan Anda dapat [menghubungkan ke pengambilan rahasia](retrieving-secrets_cache-go_CacheHook.md) untuk menambahkan lebih banyak fungsionalitas.
Cache tidak memaksa pengumpulan sampah setelah referensi cache dibebaskan. Implementasi cache tidak termasuk pembatalan cache. Implementasi cache difokuskan di sekitar cache itu sendiri, dan tidak dikeraskan atau difokuskan keamanan. Jika Anda memerlukan keamanan tambahan seperti mengenkripsi item dalam cache, gunakan antarmuka dan metode abstrak yang disediakan.
Untuk menggunakan komponen, Anda harus memiliki yang berikut:
+ AWS SDK for Go. Lihat [AWS SDKs](asm_access.md#asm-sdks).
Untuk mengunduh kode sumber, lihat [Secrets Manager Go caching client](https://github.com/aws/aws-secretsmanager-caching-go ) di GitHub.
Untuk menyiapkan lingkungan pengembangan Go, lihat [Golang Memulai](https://golang.org/doc/install) di situs web Go Programming Language.
**Izin yang diperlukan:**
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`
Untuk informasi selengkapnya, lihat [Referensi izin](auth-and-access.md#reference_iam-permissions).
**Topics**
+ [jenis Cache](retrieving-secrets_cache-go_cache.md)
+ [jenis CacheConfig](retrieving-secrets_cache-go_CacheConfig.md)
+ [jenis CacheHook](retrieving-secrets_cache-go_CacheHook.md)
**Example Ambil rahasia**
Contoh kode berikut menunjukkan fungsi Lambda yang mengambil rahasia.
```
package main
import (
"github.com/aws/aws-lambda-go/lambda"
"github.com/aws/aws-secretsmanager-caching-go/secretcache"
)
var (
secretCache, _ = secretcache.New()
)
func HandleRequest(secretId string) string {
result, _ := secretCache.GetSecretString(secretId)
// Use the secret, return success
}
func main() {
lambda. Start( HandleRequest)
}
```
# jenis Cache
Cache dalam memori untuk rahasia yang diminta dari Secrets Manager. Anda menggunakan [GetSecretString](#retrieving-secrets_cache-go_cache_operations_GetCachedSecret) atau [GetSecretBinary](#retrieving-secrets_cache-go_cache_operations_GetSecretBinary) untuk mengambil rahasia dari cache.
Contoh berikut menunjukkan cara mengkonfigurasi pengaturan cache.
```
// Create a custom secretsmanager client
client := getCustomClient()
// Create a custom CacheConfig struct
config := secretcache. CacheConfig{
MaxCacheSize: secretcache.DefaultMaxCacheSize + 10,
VersionStage: secretcache.DefaultVersionStage,
CacheItemTTL: secretcache.DefaultCacheItemTTL,
}
// Instantiate the cache
cache, _ := secretcache.New(
func( c *secretcache.Cache) { c. CacheConfig = config },
func( c *secretcache.Cache) { c. Client = client },
)
```
Untuk informasi selengkapnya, termasuk contoh, lihat[Dapatkan nilai rahasia Secrets Manager menggunakan Go dengan caching sisi klien](retrieving-secrets_cache-go.md).
## Metode
### Baru
`func New(optFns ...func(*Cache)) (*Cache, error)`
Baru membangun cache rahasia menggunakan opsi fungsional, menggunakan default sebaliknya. Menginisialisasi SecretsManager Klien dari sesi baru. Menginisialisasi CacheConfig ke nilai default. Menginisialisasi cache LRU dengan ukuran maks default.
### GetSecretString
`func (c *Cache) GetSecretString(secretId string) (string, error)`
GetSecretString mendapatkan nilai string rahasia dari cache untuk ID rahasia yang diberikan. Mengembalikan string rahasia dan kesalahan jika operasi gagal.
### GetSecretStringWithStage
`func (c *Cache) GetSecretStringWithStage(secretId string, versionStage string) (string, error)`
GetSecretStringWithStage mendapatkan nilai string rahasia dari cache untuk ID rahasia dan [tahap versi](whats-in-a-secret.md#term_version) yang diberikan. Mengembalikan string rahasia dan kesalahan jika operasi gagal.
### GetSecretBinary
`func (c *Cache) GetSecretBinary(secretId string) ([]byte, error) {`
GetSecretBinary mendapatkan nilai biner rahasia dari cache untuk ID rahasia yang diberikan. Mengembalikan biner rahasia dan kesalahan jika operasi gagal.
### GetSecretBinaryWithStage
`func (c *Cache) GetSecretBinaryWithStage(secretId string, versionStage string) ([]byte, error)`
GetSecretBinaryWithStage mendapatkan nilai biner rahasia dari cache untuk ID rahasia dan [tahap versi](whats-in-a-secret.md#term_version) yang diberikan. Mengembalikan biner rahasia dan kesalahan jika operasi gagal.
# jenis CacheConfig
Opsi konfigurasi cache untuk [Cache](retrieving-secrets_cache-go_cache.md), seperti ukuran cache maksimum, [tahap versi](whats-in-a-secret.md#term_version) default, dan Time to Live (TTL) untuk rahasia cache.
```
type CacheConfig struct {
// The maximum cache size. The default is 1024 secrets.
MaxCacheSize int
// The TTL of a cache item in nanoseconds. The default is
// 3.6e10^12 ns or 1 hour.
CacheItemTTL int64
// The version of secrets that you want to cache. The default
// is "AWSCURRENT".
VersionStage string
// Used to hook in-memory cache updates.
Hook CacheHook
}
```
# jenis CacheHook
Antarmuka untuk menghubungkan ke [Cache](retrieving-secrets_cache-go_cache.md) untuk melakukan tindakan pada rahasia yang disimpan dalam cache.
## Metode
### Masukan
`Put(data interface{}) interface{}`
Mempersiapkan objek untuk disimpan dalam cache.
### Dapatkan
`Get(data interface{}) interface{}`
Mendapatkan objek dari objek yang di-cache.
# Dapatkan nilai rahasia Secrets Manager menggunakan Go AWS SDK
Dalam aplikasi, Anda dapat mengambil rahasia Anda dengan menelepon `GetSecretValue` atau `BatchGetSecretValue` di salah satu file. AWS SDKs Namun, kami menyarankan Anda menyimpan nilai rahasia Anda dengan menggunakan caching sisi klien. Rahasia caching meningkatkan kecepatan dan mengurangi biaya Anda.
Untuk aplikasi Go, gunakan [komponen caching berbasis Secrets Manager Go](retrieving-secrets_cache-go.md) atau panggil SDK secara langsung dengan atau. [https://docs.aws.amazon.com/sdk-for-go/api/service/secretsmanager/#SecretsManager.GetSecretValue](https://docs.aws.amazon.com/sdk-for-go/api/service/secretsmanager/#SecretsManager.GetSecretValue)
Contoh kode berikut menunjukkan cara mendapatkan nilai rahasia Secrets Manager.
**Izin yang diperlukan:** `secretsmanager:GetSecretValue`
```
// Use this code snippet in your app.
// If you need more information about configurations or implementing the sample code, visit the AWS docs:
// https://aws.github.io/aws-sdk-go-v2/docs/getting-started/
import (
"context"
"log"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/aws-sdk-go-v2/service/secretsmanager"
)
func main() {
secretName := "<<{{MySecretName}}>>"
region := "<<{{MyRegionName}}>>"
config, err := config.LoadDefaultConfig(context.TODO(), config.WithRegion(region))
if err != nil {
log.Fatal(err)
}
// Create Secrets Manager client
svc := secretsmanager.NewFromConfig(config)
input := &secretsmanager.GetSecretValueInput{
SecretId: aws.String(secretName),
VersionStage: aws.String("AWSCURRENT"), // VersionStage defaults to AWSCURRENT if unspecified
}
result, err := svc.GetSecretValue(context.TODO(), input)
if err != nil {
// For a list of exceptions thrown, see
// https://<<{{DocsDomain}}>>/secretsmanager/latest/apireference/API_GetSecretValue.html
log.Fatal(err.Error())
}
// Decrypts secret using the associated KMS key.
var secretString string = *result.SecretString
// Your code goes here.
}
```
# Dapatkan nilai rahasia Secrets Manager menggunakan Rust
Dalam aplikasi, Anda dapat mengambil rahasia Anda dengan menelepon `GetSecretValue` atau `BatchGetSecretValue` di salah satu file. AWS SDKs Namun, kami menyarankan Anda menyimpan nilai rahasia Anda dengan menggunakan caching sisi klien. Rahasia caching meningkatkan kecepatan dan mengurangi biaya Anda.
**Topics**
+ [Dapatkan nilai rahasia Secrets Manager menggunakan Rust dengan caching sisi klien](retrieving-secrets_cache-rust.md)
+ [Dapatkan nilai rahasia Secrets Manager menggunakan Rust AWS SDK](retrieving-secrets-rust-sdk.md)
# Dapatkan nilai rahasia Secrets Manager menggunakan Rust dengan caching sisi klien
Saat Anda mengambil rahasia, Anda dapat menggunakan komponen caching berbasis Secrets Manager Rust untuk men-cache untuk digunakan di masa mendatang. Mengambil rahasia yang di-cache lebih cepat daripada mengambilnya dari Secrets Manager. Karena ada biaya untuk memanggil Secrets Manager APIs, menggunakan cache dapat mengurangi biaya Anda. Untuk semua cara Anda dapat mengambil rahasia, lihat[Dapatkan rahasia](retrieving-secrets.md).
Kebijakan cache adalah First In First Out (FIFO), jadi ketika cache harus membuang rahasia, ia membuang rahasia tertua. Secara default, cache menyegarkan rahasia setiap jam. Anda dapat mengonfigurasi yang berikut ini:
+ `max_size`— Jumlah maksimum rahasia cache yang harus disimpan sebelum mengusir rahasia yang belum diakses baru-baru ini.
+ `ttl`— Durasi item yang di-cache dianggap valid sebelum memerlukan penyegaran keadaan rahasia.
Implementasi cache tidak termasuk pembatalan cache. Implementasi cache difokuskan di sekitar cache itu sendiri, dan tidak dikeraskan atau difokuskan keamanan. Jika Anda memerlukan keamanan tambahan seperti mengenkripsi item dalam cache, gunakan sifat yang disediakan untuk memodifikasi cache.
Untuk menggunakan komponen, Anda harus memiliki lingkungan pengembangan Rust 2021 dengan`tokio`. Untuk informasi selengkapnya, lihat [Memulai](https://www.rust-lang.org/learn/get-started) situs web Rust Programming Language.
Untuk mengunduh kode sumber, lihat [Secrets Manager Rust-based caching client](https://github.com/aws/aws-secretsmanager-agent/tree/main/aws_secretsmanager_caching) component on. GitHub
Untuk menginstal komponen caching, gunakan perintah berikut.
```
cargo add aws_secretsmanager_caching
```
**Izin yang diperlukan:**
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`
Untuk informasi selengkapnya, lihat [Referensi izin](auth-and-access.md#reference_iam-permissions).
**Example Ambil rahasia**
Contoh berikut menunjukkan bagaimana untuk mendapatkan nilai rahasia untuk rahasia bernama*MyTest*.
```
use aws_secretsmanager_caching::SecretsManagerCachingClient;
use std::num::NonZeroUsize;
use std::time::Duration;
let client = match SecretsManagerCachingClient::default(
NonZeroUsize::new(10).unwrap(),
Duration::from_secs(60),
)
.await
{
Ok(c) => c,
Err(_) => panic!("Handle this error"),
};
let secret_string = match client.get_secret_value("MyTest", None, None).await {
Ok(s) => s.secret_string.unwrap(),
Err(_) => panic!("Handle this error"),
};
// Your code here
```
**Example Membuat Instantiasi Cache dengan konfigurasi khusus dan klien khusus**
Contoh berikut menunjukkan cara mengkonfigurasi cache dan kemudian mendapatkan nilai rahasia untuk rahasia bernama*MyTest*.
```
let config = aws_config::load_defaults(BehaviorVersion::latest())
.await
.into_builder()
.region(Region::from_static("us-west-2"))
.build();
let asm_builder = aws_sdk_secretsmanager::config::Builder::from(&config);
let client = match SecretsManagerCachingClient::from_builder(
asm_builder,
NonZeroUsize::new(10).unwrap(),
Duration::from_secs(60),
)
.await
{
Ok(c) => c,
Err(_) => panic!("Handle this error"),
};
let secret_string = client
.get_secret_value("MyTest", None, None)
.await
{
Ok(c) => c.secret_string.unwrap(),
Err(_) => panic!("Handle this error"),
};
// Your code here
```
```
# Dapatkan nilai rahasia Secrets Manager menggunakan Rust AWS SDK
Dalam aplikasi, Anda dapat mengambil rahasia Anda dengan menelepon `GetSecretValue` atau `BatchGetSecretValue` di salah satu file. AWS SDKs Namun, kami menyarankan Anda menyimpan nilai rahasia Anda dengan menggunakan caching sisi klien. Rahasia caching meningkatkan kecepatan dan mengurangi biaya Anda.
Untuk aplikasi Rust, gunakan [komponen caching berbasis Secrets Manager Rust](retrieving-secrets_cache-rust.md) atau panggil [SDK](https://docs.rs/releases/search?query=aws-sdk-secretsmanager) secara langsung dengan atau. GetSecretValue BatchGetSecretValue
Contoh kode berikut menunjukkan cara mendapatkan nilai rahasia Secrets Manager.
**Izin yang diperlukan:** `secretsmanager:GetSecretValue`
```
async fn show_secret(client: &Client, name: &str) -> Result<(), Error> {
let resp = client.get_secret_value().secret_id(name).send().await?;
println!("Value: {}", resp.secret_string().unwrap_or("No value!"));
Ok(())
}
```
# Gunakan AWS Secrets Manager rahasia di Amazon Elastic Kubernetes Service
Untuk menampilkan secret from AWS Secrets Manager (ASCP) sebagai file yang dipasang di Amazon EKS Pods, Anda dapat menggunakan AWS Secrets and Configuration Provider untuk Kubernetes Secrets Store CSI Driver. ASCP bekerja dengan Amazon Elastic Kubernetes Service 1.17\$1 yang menjalankan grup node Amazon EC2. AWS Fargate grup node tidak didukung. Dengan ASCP, Anda dapat menyimpan dan mengelola rahasia Anda di Secrets Manager dan kemudian mengambilnya melalui beban kerja Anda yang berjalan di Amazon EKS. Jika rahasia Anda berisi beberapa pasangan nilai kunci dalam format JSON, Anda dapat memilih mana yang akan dipasang di Amazon EKS. ASCP menggunakan JMESPath sintaks untuk menanyakan pasangan kunci-nilai dalam rahasia Anda. ASCP juga bekerja dengan parameter Parameter Store. ASCP menawarkan dua metode otentikasi dengan Amazon EKS Pendekatan pertama menggunakan Peran IAM untuk Akun Layanan (IRSA). Pendekatan kedua menggunakan Pod Identities. Setiap pendekatan memiliki manfaat dan kasus penggunaannya.
## ASCP dengan Peran IAM untuk Akun Layanan (IRSA)
ASCP dengan Peran IAM untuk Akun Layanan (IRSA) memungkinkan Anda memasang rahasia dari file AWS Secrets Manager sebagai di Pod Amazon EKS Anda. Pendekatan ini cocok ketika:
+ Anda perlu memasang rahasia sebagai file di Pod Anda.
+ Anda menggunakan Amazon EKS versi 1.17 atau yang lebih baru dengan grup node Amazon EC2.
+ Anda ingin mengambil pasangan nilai kunci tertentu dari rahasia berformat JSON.
Untuk informasi selengkapnya, lihat [Gunakan AWS Rahasia dan Penyedia Konfigurasi CSI dengan Peran IAM untuk Akun Layanan (IRSA)](integrating_ascp_irsa.md).
## ASCP dengan Identitas Pod
Metode ASCP dengan Pod Identity meningkatkan keamanan dan menyederhanakan konfigurasi untuk mengakses rahasia di Amazon EKS. Pendekatan ini bermanfaat ketika:
+ Anda memerlukan manajemen izin yang lebih terperinci di tingkat Pod.
+ Anda menggunakan Amazon EKS versi 1.24 atau yang lebih baru.
+ Anda ingin meningkatkan kinerja dan skalabilitas.
Untuk informasi selengkapnya, lihat [Gunakan CSI Penyedia AWS Rahasia dan Konfigurasi dengan Pod Identity untuk Amazon EKS](ascp-pod-identity-integration.md).
## Memilih pendekatan yang tepat
Pertimbangkan faktor-faktor berikut ketika memutuskan antara ASCP dengan IRSA dan ASCP dengan Pod Identity:
+ Amazon EKSversion: Pod Identity membutuhkan Amazon EKS 1.24\$1, sedangkan driver CSI bekerja dengan Amazon EKS 1.17\$1.
+ Persyaratan keamanan: Pod Identity menawarkan kontrol yang lebih terperinci pada level Pod.
+ Kinerja: Pod Identity umumnya berkinerja lebih baik di lingkungan skala tinggi.
+ Kompleksitas: Pod Identity menyederhanakan penyiapan dengan menghilangkan kebutuhan akan akun layanan terpisah.
Pilih metode yang paling sesuai dengan kebutuhan spesifik Anda dan lingkungan Amazon EKS.
# Instal ASCP untuk Amazon EKS
Bagian ini menjelaskan cara menginstal Penyedia AWS Rahasia dan Konfigurasi untuk Amazon EKS. Dengan ASCP, Anda dapat memasang rahasia dari Secrets Manager dan parameter dari AWS Systems Manager sebagai file di Amazon EKS Pods.
## Prasyarat
+ Klaster Amazon EKS
+ Versi 1.24 atau yang lebih baru untuk Pod Identity
+ Versi 1.17 atau yang lebih baru untuk IRSA
+ Yang AWS CLI diinstal dan dikonfigurasi
+ kubectl diinstal dan dikonfigurasi untuk klaster Amazon EKS Anda
+ Helm (versi 3.0 atau yang lebih baru)
## Instal dan konfigurasikan ASCP
ASCP tersedia GitHub di repositori [secrets-store-csi-provider-aws](https://github.com/aws/secrets-store-csi-driver-provider-aws). Repo juga berisi contoh file YAMAL untuk membuat dan memasang rahasia.
Selama instalasi, Anda dapat mengkonfigurasi ASCP untuk menggunakan titik akhir FIPS. Untuk daftar titik akhir, lihat[AWS Secrets Manager titik akhir](asm_access.md#endpoints).
**Untuk menginstal ASCP sebagai add-on EKS**
1. Instal `eksctl` ([petunjuk instalasi](https://docs.aws.amazon.com/eks/latest/eksctl/installation.html))
1. Jalankan perintah berikut untuk menginstal add-on dengan [konfigurasi default](https://github.com/aws/secrets-store-csi-driver-provider-aws/blob/main/charts/secrets-store-csi-driver-provider-aws/values.yaml):
```
eksctl create addon --cluster --name aws-secrets-store-csi-driver-provider
```
Jika Anda ingin mengkonfigurasi add-on, jalankan perintah instalasi berikut sebagai gantinya:
```
aws eks create-addon --cluster-name --addon-name aws-secrets-store-csi-driver-provider --configuration-values 'file://path/to/config.yaml'
```
File konfigurasi dapat berupa file YAMM atau JSON. Untuk melihat skema konfigurasi untuk add-on:
1. Jalankan perintah berikut dan catat versi terbaru dari add-on:
```
aws eks describe-addon-versions --addon-name aws-secrets-store-csi-driver-provider
```
1. Jalankan perintah berikut untuk melihat skema konfigurasi add-on, ganti `` dengan versi dari langkah sebelumnya:
```
aws eks describe-addon-configuration --addon-name aws-secrets-store-csi-driver-provider --addon-version
```
**Untuk menginstal ASCP dengan menggunakan Helm**
1. Untuk memastikan repo menunjuk ke grafik terbaru, gunakan `helm repo update.`
1. Instal bagan. Berikut ini adalah contoh `helm install` perintah:
```
helm install -n kube-system secrets-provider-aws aws-secrets-manager/secrets-store-csi-driver-provider-aws
```
1. Untuk menggunakan endpoint FIPS, tambahkan tanda berikut: `--set useFipsEndpoint=true`
1. Untuk mengonfigurasi pelambatan, tambahkan tanda berikut: `--set-json 'k8sThrottlingParams={"qps": "number of queries per second", "burst": "number of queries per second"}'`
1. Jika Secrets Store CSI Driver sudah diinstal pada cluster Anda, tambahkan tanda berikut:`--set secrets-store-csi-driver.install=false`. Ini akan melewatkan menginstal Secrets Store CSI Driver sebagai dependensi.
**Untuk menginstal dengan menggunakan YAMAL di repo**
+ Gunakan perintah berikut.
```
helm repo add secrets-store-csi-driver https://kubernetes-sigs.github.io/secrets-store-csi-driver/charts
helm install -n kube-system csi-secrets-store secrets-store-csi-driver/secrets-store-csi-driver
kubectl apply -f https://raw.githubusercontent.com/aws/secrets-store-csi-driver-provider-aws/main/deployment/aws-provider-installer.yaml
```
## Verifikasi instalasi
Untuk memverifikasi instalasi kluster EKS Anda, driver Secrets Store CSI, dan plugin ASCP, ikuti langkah-langkah berikut:
1. Verifikasi kluster EKS:
```
eksctl get cluster --name clusterName
```
Perintah ini harus mengembalikan informasi tentang cluster Anda.
1. Verifikasi instalasi driver Secrets Store CSI:
```
kubectl get pods -n kube-system -l app=secrets-store-csi-driver
```
Anda akan melihat Pod berjalan dengan nama seperti`csi-secrets-store-secrets-store-csi-driver-xxx`.
1. Verifikasi instalasi plugin ASCP:
------
#### [ YAML installation ]
```
$ kubectl get pods -n kube-system -l app=csi-secrets-store-provider-aws
```
Contoh output:
```
NAME READY STATUS RESTARTS AGE
csi-secrets-store-provider-aws-12345 1/1 Running 0 2m
```
------
#### [ Helm installation ]
```
$ kubectl get pods -n kube-system -l app=secrets-store-csi-driver-provider-aws
```
Contoh output:
```
NAME READY STATUS RESTARTS AGE
secrets-provider-aws-secrets-store-csi-driver-provider-67890 1/1 Running 0 2m
```
------
Anda akan melihat Pod di `Running` negara bagian.
Setelah menjalankan perintah ini, jika semuanya diatur dengan benar, Anda akan melihat semua komponen berjalan tanpa kesalahan. Jika mengalami masalah apa pun, Anda mungkin perlu memecahkan masalah dengan memeriksa log Pod tertentu yang mengalami masalah.
## Pemecahan masalah
1. Untuk memeriksa log penyedia ASCP, jalankan:
```
kubectl logs -n kube-system -l app=csi-secrets-store-provider-aws
```
1. Periksa status semua pod di `kube-system` namespace:
```
kubectl -n kube-system get pods
```
```
kubectl -n kube-system logs pod/PODID
```
Semua Pod yang terkait dengan driver CSI dan ASCP harus berada dalam status 'Berjalan'.
1. Periksa versi driver CSI:
```
kubectl get csidriver secrets-store.csi.k8s.io -o yaml
```
Perintah ini harus mengembalikan informasi tentang driver CSI yang diinstal.
## Sumber daya tambahan
Untuk informasi selengkapnya tentang penggunaan ASCP dengan Amazon EKS, lihat sumber daya berikut:
+ [Menggunakan Pod Identity dengan Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/pod-identities.html)
+ [AWS Secrets Store CSI Driver di GitHub](https://github.com/aws/secrets-store-csi-driver-provider-aws)
# Gunakan CSI Penyedia AWS Rahasia dan Konfigurasi dengan Pod Identity untuk Amazon EKS
Integrasi AWS Secrets and Configuration Provider dengan Pod Identity Agent untuk Amazon Elastic Kubernetes Service memberikan peningkatan keamanan, konfigurasi yang disederhanakan, dan peningkatan kinerja untuk aplikasi yang berjalan di Amazon EKS. Pod Identity menyederhanakan autentikasi IAM untuk Amazon EKS saat mengambil rahasia dari Secrets Manager atau parameter dari Parameter Store. AWS Systems Manager
Amazon EKS Pod Identity merampingkan proses konfigurasi izin IAM untuk aplikasi Kubernetes dengan mengizinkan izin diatur secara langsung melalui antarmuka Amazon EKS, mengurangi jumlah langkah dan menghilangkan kebutuhan untuk beralih antara Amazon EKS dan layanan IAM. Pod Identity memungkinkan penggunaan peran IAM tunggal di beberapa cluster tanpa memperbarui kebijakan kepercayaan dan mendukung [tag sesi peran](https://docs.aws.amazon.com/eks/latest/userguide/pod-id-abac.html#pod-id-abac-tags) untuk kontrol akses yang lebih terperinci. Pendekatan ini tidak hanya menyederhanakan manajemen kebijakan dengan mengizinkan penggunaan kembali kebijakan izin di seluruh peran tetapi juga meningkatkan keamanan dengan mengaktifkan akses ke AWS sumber daya berdasarkan tag yang cocok.
## Cara kerjanya
1. Pod Identity memberikan peran IAM ke Pod.
1. ASCP menggunakan peran ini untuk mengautentikasi dengan. Layanan AWS
1. Jika diotorisasi, ASCP mengambil rahasia yang diminta dan membuatnya tersedia untuk Pod.
Untuk informasi selengkapnya, lihat [Memahami cara kerja Identitas Pod Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/pod-id-how-it-works.html) di *Panduan Pengguna Amazon EKS*.
## Prasyarat
**penting**
Pod Identity hanya didukung untuk Amazon EKS di cloud. Ini tidak didukung untuk [Amazon EKS Anywhere](https://aws.amazon.com/eks/eks-anywhere/), [Layanan OpenShift Red Hat di AWS](https://aws.amazon.com/rosa/), atau cluster Kubernetes yang dikelola sendiri di instans Amazon EC2.
+ Cluster Amazon EKS (versi 1.24 atau yang lebih baru)
+ Akses ke AWS CLI dan Amazon EKS cluster melalui `kubectl`
+ Akses ke dua Akun AWS (untuk akses lintas akun)
## Instal Agen Identitas Pod Amazon EKS
Untuk menggunakan Pod Identity dengan klaster Anda, Anda harus menginstal add-on Amazon EKS Pod Identity Agent.
**Untuk menginstal Agen Identitas Pod**
+ Instal add-on Pod Identity Agent di klaster Anda:
```
eksctl create addon \
--name eks-pod-identity-agent \
--cluster clusterName \
--region region
```
## Mengatur ASCP dengan Pod Identity
1. Buat kebijakan izin yang memberikan `secretsmanager:GetSecretValue` dan `secretsmanager:DescribeSecret` mengizinkan rahasia yang perlu diakses oleh Pod. Untuk contoh kebijakan, lihat [Contoh: Izin untuk membaca dan menggambarkan rahasia individu](auth-and-access_iam-policies.md#auth-and-access_examples-read-and-describe).
1. Buat peran IAM yang dapat diasumsikan oleh prinsipal layanan Amazon EKS untuk Pod Identity:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "pods.eks.amazonaws.com"
},
"Action": [
"sts:AssumeRole",
"sts:TagSession"
]
}
]
}
```
------
Lampirkan kebijakan IAM ke peran:
```
aws iam attach-role-policy \
--role-name MY_ROLE \
--policy-arn POLICY_ARN
```
1. Buat asosiasi Pod Identity. Sebagai contoh, lihat [Membuat asosiasi Identitas Pod](https://docs.aws.amazon.com/eks/latest/userguide/pod-id-association.html#pod-id-association-create) di *Panduan Pengguna Amazon EKS*
1. Buat `SecretProviderClass` yang menentukan rahasia mana yang akan dipasang di Pod:
```
kubectl apply -f https://raw.githubusercontent.com/aws/secrets-store-csi-driver-provider-aws/main/examples/ExampleSecretProviderClass-PodIdentity.yaml
```
Perbedaan utama `SecretProviderClass` antara IRSA dan Pod Identity adalah parameter `usePodIdentity` opsional. Ini adalah bidang opsional yang menentukan pendekatan otentikasi. Ketika tidak ditentukan, default menggunakan Peran IAM untuk Akun Layanan (IRSA).
+ Untuk menggunakan EKS Pod Identity, gunakan salah satu dari nilai-nilai ini:`"true", "True", "TRUE", "t", "T"`.
+ Untuk secara eksplisit menggunakan IRSA, atur ke salah satu nilai ini:. `"false", "False", "FALSE", "f", or "F"`
1. Terapkan Pod yang memasang rahasia di bawah: `/mnt/secrets-store`
```
kubectl apply -f https://raw.githubusercontent.com/aws/secrets-store-csi-driver-provider-aws/main/examples/ExampleDeployment-PodIdentity.yaml
```
1. Jika Anda menggunakan kluster Amazon EKS pribadi, pastikan VPC tempat cluster berada memiliki AWS STS titik akhir. *Untuk informasi tentang membuat titik akhir, lihat Titik akhir [VPC Antarmuka](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_interface_vpc_endpoints.html) di AWS Identity and Access Management Panduan Pengguna.*
### Verifikasi pemasangan rahasia
Untuk memverifikasi bahwa rahasia sudah terpasang dengan benar, jalankan perintah berikut:
```
kubectl exec -it $(kubectl get pods | awk '/pod-identity-deployment/{print $1}' | head -1) -- cat /mnt/secrets-store/MySecret
```
**Untuk mengatur Amazon EKS Pod Identity untuk mengakses rahasia di Secrets Manager**
1. Buat kebijakan izin yang memberikan `secretsmanager:GetSecretValue` dan `secretsmanager:DescribeSecret` mengizinkan rahasia yang perlu diakses oleh Pod. Untuk contoh kebijakan, lihat [Contoh: Izin untuk membaca dan menggambarkan rahasia individu](auth-and-access_iam-policies.md#auth-and-access_examples-read-and-describe).
1. Buat rahasia di Secrets Manager, jika Anda belum memilikinya.
## Pemecahan Masalah
Anda dapat melihat sebagian besar kesalahan dengan menjelaskan penerapan Pod.
**Untuk melihat pesan galat untuk penampung Anda**
1. Dapatkan daftar nama Pod dengan perintah berikut. Jika Anda tidak menggunakan namespace default, gunakan. `-n NAMESPACE`
```
kubectl get pods
```
1. Untuk mendeskripsikan Pod, dalam perintah berikut, *PODID* gunakan ID Pod dari Pod yang Anda temukan di langkah sebelumnya. Jika Anda tidak menggunakan namespace default, gunakan. `-n NAMESPACE`
```
kubectl describe pod/PODID
```
**Untuk melihat kesalahan untuk ASCP**
+ Untuk menemukan informasi selengkapnya di log penyedia, dalam perintah berikut, *PODID* gunakan ID Pod *csi-secrets-store-provider-aws*.
```
kubectl -n kube-system get pods
kubectl -n kube-system logs pod/PODID
```
# Gunakan AWS Rahasia dan Penyedia Konfigurasi CSI dengan Peran IAM untuk Akun Layanan (IRSA)
**Topics**
+ [Prasyarat](#prerequisites)
+ [Mengatur kontrol akses](#integrating_ascp_irsa_access)
+ [Identifikasi rahasia mana yang akan dipasang](#integrating_ascp_irsa_mount)
+ [Pemecahan Masalah](#integrating_ascp_irsa_trouble)
## Prasyarat
+ Cluster Amazon EKS (versi 1.17 atau yang lebih baru)
+ Akses ke AWS CLI dan Amazon EKS cluster melalui `kubectl`
## Mengatur kontrol akses
ASCP mengambil Amazon EKS Pod Identity dan menukarnya dengan peran IAM. Anda menetapkan izin dalam kebijakan IAM untuk peran IAM tersebut. Ketika ASCP mengasumsikan peran IAM, ia mendapat akses ke rahasia yang Anda otorisasi. Kontainer lain tidak dapat mengakses rahasia kecuali Anda juga mengaitkannya dengan peran IAM.
**Untuk memberikan Amazon EKS Pod akses ke rahasia di Secrets Manager**
1. Buat kebijakan izin yang memberikan `secretsmanager:GetSecretValue` dan `secretsmanager:DescribeSecret` mengizinkan rahasia yang perlu diakses oleh Pod. Untuk contoh kebijakan, lihat [Contoh: Izin untuk membaca dan menggambarkan rahasia individu](auth-and-access_iam-policies.md#auth-and-access_examples-read-and-describe).
1. Buat penyedia OpenID Connect (OIDC) IAM untuk cluster jika Anda belum memilikinya. Untuk informasi selengkapnya, lihat [Membuat penyedia IAM OIDC untuk klaster Anda di Panduan](https://docs.aws.amazon.com/eks/latest/userguide/enable-iam-roles-for-service-accounts.html) Pengguna *Amazon EKS*.
1. Buat [peran IAM untuk akun layanan](https://docs.aws.amazon.com/eks/latest/userguide/iam-roles-for-service-accounts.html) dan lampirkan kebijakan ke dalamnya. Untuk informasi selengkapnya, lihat [Membuat peran IAM untuk akun layanan](https://docs.aws.amazon.com/eks/latest/userguide/iam-roles-for-service-accounts.html) di *Panduan Pengguna Amazon EKS*.
1. Jika Anda menggunakan kluster Amazon EKS pribadi, pastikan VPC tempat cluster berada memiliki AWS STS titik akhir. *Untuk informasi tentang membuat titik akhir, lihat Titik akhir [VPC Antarmuka](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_interface_vpc_endpoints.html) di AWS Identity and Access Management Panduan Pengguna.*
## Identifikasi rahasia mana yang akan dipasang
Untuk menentukan rahasia mana yang dipasang ASCP di Amazon EKS sebagai file di sistem file, Anda membuat file YAMAL. [SecretProviderClass](ascp-examples.md#ascp-examples-secretproviderclass) `SecretProviderClass`Daftar rahasia untuk dipasang dan nama file untuk dipasang sebagai. `SecretProviderClass`Harus berada di namespace yang sama dengan Amazon EKS Pod yang direferensikannya.
### Pasang rahasia sebagai file
[Petunjuk berikut menunjukkan cara memasang rahasia sebagai file menggunakan contoh file YAML.yaml [ExampleSecretProviderClassdan.yaml](https://github.com/aws/secrets-store-csi-driver-provider-aws/blob/main/examples/ExampleSecretProviderClass-IRSA.yaml). ExampleDeployment](https://github.com/aws/secrets-store-csi-driver-provider-aws/blob/main/examples/ExampleDeployment-IRSA.yaml)
**Untuk memasang rahasia di Amazon EKS**
1. Terapkan `SecretProviderClass` ke Pod:
```
kubectl apply -f ExampleSecretProviderClass.yaml
```
1. Menerapkan Pod Anda:
```
kubectl apply -f ExampleDeployment.yaml
```
1. ASCP memasang file.
## Pemecahan Masalah
Anda dapat melihat sebagian besar kesalahan dengan menjelaskan penerapan Pod.
**Untuk melihat pesan galat untuk penampung**
1. Dapatkan daftar nama Pod dengan perintah berikut. Jika Anda tidak menggunakan namespace default, gunakan. `-n nameSpace`
```
kubectl get pods
```
1. Untuk mendeskripsikan Pod, dalam perintah berikut, *podId* gunakan ID Pod dari Pod yang Anda temukan di langkah sebelumnya. Jika Anda tidak menggunakan namespace default, gunakan. `-n nameSpace`
```
kubectl describe pod/podId
```
**Untuk melihat kesalahan untuk ASCP**
+ Untuk menemukan informasi selengkapnya di log penyedia, dalam perintah berikut, *podId* gunakan ID Pod *csi-secrets-store-provider-aws*.
```
kubectl -n kube-system get pods
kubectl -n kube-system logs Pod/podId
```
+
**Verifikasi bahwa `SecretProviderClass` CRD diinstal:**
```
kubectl get crd secretproviderclasses.secrets-store.csi.x-k8s.io
```
Perintah ini harus mengembalikan informasi tentang definisi sumber daya `SecretProviderClass` khusus.
+
**Verifikasi bahwa SecretProviderClass objek telah dibuat.**
```
kubectl get secretproviderclass SecretProviderClassName -o yaml
```
# AWS Contoh kode Penyedia Rahasia dan Konfigurasi
## Contoh otentikasi ASCP dan kontrol akses
### Contoh: Kebijakan IAM yang mengizinkan layanan Amazon EKS Pod Identity (pods.eks.amazonaws.com) untuk mengambil peran dan menandai sesi:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "pods.eks.amazonaws.com"
},
"Action": [
"sts:AssumeRole",
"sts:TagSession"
]
}
]
}
```
------
## SecretProviderClass
Anda menggunakan YAMAL untuk menjelaskan rahasia mana yang akan dipasang di Amazon EKS menggunakan ASCP. Sebagai contoh, lihat [SecretProviderClass penggunaan](#ascp-scenarios-secretproviderclass).
### SecretProviderClass Struktur YAMAL
```
apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
name: name
spec:
provider: aws
parameters:
region:
failoverRegion:
pathTranslation:
usePodIdentity:
preferredAddressType:
objects:
```
Bidang parameter berisi rincian permintaan pemasangan:
**region**
(Opsional) Wilayah AWS Rahasianya. Jika Anda tidak menggunakan bidang ini, ASCP mencari Region dari anotasi pada node. Pencarian ini menambahkan overhead ke permintaan mount, jadi sebaiknya Anda menyediakan Region untuk klaster yang menggunakan Pod dalam jumlah besar.
Jika Anda juga menentukan`failoverRegion`, ASCP mencoba untuk mengambil rahasia dari kedua Wilayah. Jika salah satu Wilayah mengembalikan kesalahan 4xx, misalnya untuk masalah otentikasi, ASCP tidak memasang salah satu rahasia. Jika rahasia berhasil diambil`region`, maka ASCP memasang nilai rahasia itu. Jika rahasia tidak berhasil diambil dari`region`, tetapi berhasil diambil dari`failoverRegion`, maka ASCP memasang nilai rahasia itu.
**FailOverRegion**
(Opsional) Jika Anda menyertakan bidang ini, ASCP mencoba mengambil rahasia dari Wilayah yang ditentukan dalam `region` dan bidang ini. Jika salah satu Wilayah mengembalikan kesalahan 4xx, misalnya untuk masalah otentikasi, ASCP tidak memasang salah satu rahasia. Jika rahasia berhasil diambil`region`, maka ASCP memasang nilai rahasia itu. Jika rahasia tidak berhasil diambil dari`region`, tetapi berhasil diambil dari`failoverRegion`, maka ASCP memasang nilai rahasia itu. Untuk contoh cara menggunakan bidang ini, lihat[Kegagalan rahasia Multi-Wilayah](#multi-region-failover).
**PathTranslation**
(Opsional) Karakter substitusi tunggal untuk digunakan jika nama file di Amazon EKS akan berisi karakter pemisah jalur, seperti garis miring (/) di Linux. ASCP tidak dapat membuat file yang dipasang yang berisi karakter pemisah jalur. Sebagai gantinya, ASCP menggantikan karakter pemisah jalur dengan karakter yang berbeda. Jika Anda tidak menggunakan bidang ini, karakter pengganti adalah garis bawah (\$1), jadi misalnya, `My/Path/Secret` dipasang sebagai. `My_Path_Secret`
Untuk mencegah substitusi karakter, masukkan string`False`.
**usePodIdentity**
(Opsional) Menentukan pendekatan otentikasi. Ketika tidak ditentukan, default ke IAM Roles for Service Accounts (IRSA) (IRSA).
+ Untuk menggunakan EKS Pod Identity, gunakan salah satu nilai berikut: `"true"` “`"True"`,`"TRUE"`,`"t"`,, atau`"T"`.
+ Untuk secara eksplisit menggunakan IRSA, atur ke salah satu nilai ini:`"false"`,,, `"False"` `"FALSE"``"f"`, atau `"F"` “=.
**preferredAddressType**
(Opsional) Menentukan jenis alamat IP yang disukai untuk komunikasi endpoint Pod Identity Agent. Bidang ini hanya berlaku ketika menggunakan fitur EKS Pod Identity dan akan diabaikan saat menggunakan Peran IAM untuk Akun Layanan. Nilai tidak peka huruf besar/kecil. Nilai yang valid adalah:
+ `"ipv4"`, `"IPv4"` “, atau `"IPV4"` — Paksa penggunaan titik IPv4 akhir Pod Identity Agent
+ `"ipv6"`,`"IPv6"`, atau `"IPV6"` — Paksa penggunaan titik IPv6 akhir Pod Identity Agent
+ tidak ditentukan - Gunakan pemilihan titik akhir otomatis, coba IPv4 titik akhir terlebih dahulu dan kembali ke titik IPv6 akhir jika gagal IPv4
**objek**
String yang berisi deklarasi YAMAL tentang rahasia yang akan dipasang. Sebaiknya gunakan karakter string atau pipe (\$1) multi-line YAMAL.
**objectName**
Wajib. Menentukan nama rahasia atau parameter yang akan diambil. Untuk Secrets Manager ini adalah [https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_GetSecretValue.html#API_GetSecretValue_RequestParameters](https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_GetSecretValue.html#API_GetSecretValue_RequestParameters)parameter dan dapat berupa nama ramah atau ARN lengkap rahasia. Untuk SSM Parameter Store, ini adalah parameter dan dapat berupa nama atau ARN lengkap parameter. [https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_GetParameter.html#API_GetParameter_RequestParameters](https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_GetParameter.html#API_GetParameter_RequestParameters)
**objectType**
Diperlukan jika Anda tidak menggunakan Secrets Manager ARN untuk. `objectName` Bisa salah satu `secretsmanager` atau`ssmparameter`.
**Objectalias**
(Opsional) Nama file rahasia di Amazon EKS Pod. Jika Anda tidak menentukan bidang ini, `objectName` muncul sebagai nama file.
**FilePermission**
(Opsional) String oktal 4 digit yang menentukan izin file untuk memasang rahasia. Jika Anda tidak menentukan bidang ini, itu akan default ke`"0644"`.
**ObjectVersion**
(Opsional) ID versi rahasia. Tidak disarankan karena Anda harus memperbarui ID versi setiap kali Anda memperbarui rahasia. Secara default versi terbaru digunakan. Jika Anda menyertakan a`failoverRegion`, bidang ini mewakili primer`objectVersion`.
**objectVersionLabel**
(Opsional) Alias untuk versi. Defaultnya adalah versi terbaru AWSCURRENT. Untuk informasi selengkapnya, lihat [Versi rahasia](whats-in-a-secret.md#term_version). Jika Anda menyertakan a`failoverRegion`, bidang ini mewakili primer`objectVersionLabel`.
**JMESPath**
(Opsional) Peta kunci dalam rahasia file yang akan dipasang di Amazon EKS. Untuk menggunakan bidang ini, nilai rahasia Anda harus dalam format JSON. Jika Anda menggunakan bidang ini, Anda harus menyertakan subbidang `path` dan`objectAlias`.
**path**
Kunci dari pasangan kunci-nilai di JSON dari nilai rahasia. Jika bidang berisi tanda hubung, gunakan tanda kutip tunggal untuk menghindarinya, misalnya: `path: '"hyphenated-path"'`
**Objectalias**
Nama file yang akan dipasang di Amazon EKS Pod. Jika bidang berisi tanda hubung, gunakan tanda kutip tunggal untuk menghindarinya, misalnya: `objectAlias: '"hyphenated-alias"'`
**FilePermission**
(Opsional) String oktal 4 digit yang menentukan izin file untuk memasang rahasia. Jika Anda tidak menentukan bidang ini, itu akan default ke izin file objek induk.
**FailOverObject**
(Opsional) Jika Anda menentukan bidang ini, ASCP mencoba untuk mengambil kedua rahasia yang ditentukan dalam primer `objectName` dan rahasia yang ditentukan dalam sub-bidang. `failoverObject` `objectName` Jika salah satu mengembalikan kesalahan 4xx, misalnya untuk masalah otentikasi, ASCP tidak memasang salah satu rahasia. Jika rahasia berhasil diambil dari primer`objectName`, maka ASCP memasang nilai rahasia itu. Jika rahasia tidak berhasil diambil dari primer`objectName`, tetapi berhasil diambil dari failover`objectName`, maka ASCP memasang nilai rahasia itu. Jika Anda menyertakan bidang ini, Anda harus menyertakan bidang tersebut`objectAlias`. Untuk contoh cara menggunakan bidang ini, lihat[Kegagalan ke rahasia yang berbeda](#failover-secret).
Anda biasanya menggunakan bidang ini ketika rahasia failover bukan replika. Untuk contoh cara menentukan replika, lihat[Kegagalan rahasia Multi-Wilayah](#multi-region-failover).
**objectName**
Nama atau ARN lengkap dari rahasia failover. Jika Anda menggunakan ARN, Wilayah di ARN harus cocok dengan bidang. `failoverRegion`
**ObjectVersion**
(Opsional) ID versi rahasia. Harus cocok dengan yang utama`objectVersion`. Tidak disarankan karena Anda harus memperbarui ID versi setiap kali Anda memperbarui rahasia. Secara default versi terbaru digunakan.
**objectVersionLabel**
(Opsional) Alias untuk versi. Defaultnya adalah versi terbaru AWSCURRENT. Untuk informasi selengkapnya, lihat [Versi rahasia](whats-in-a-secret.md#term_version).
### Buat SecretProviderClass konfigurasi dasar untuk memasang rahasia di Pod Amazon EKS Anda.
------
#### [ Pod Identity ]
SecretProviderClass untuk menggunakan rahasia di cluster Amazon EKS yang sama:
```
apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
name: aws-secrets-manager
spec:
provider: aws
parameters:
objects: |
- objectName: "mySecret"
objectType: "secretsmanager"
usePodIdentity: "true"
```
------
#### [ IRSA ]
```
apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
name: deployment-aws-secrets
spec:
provider: aws
parameters:
objects: |
- objectName: "MySecret"
objectType: "secretsmanager"
```
------
### SecretProviderClass penggunaan
Gunakan contoh ini untuk membuat SecretProviderClass konfigurasi untuk skenario yang berbeda.
#### Contoh: Pasang rahasia dengan nama atau ARN
Contoh ini menunjukkan cara memasang tiga jenis rahasia:
+ Rahasia yang ditentukan oleh ARN lengkap
+ Rahasia yang ditentukan oleh nama
+ Versi spesifik dari rahasia
```
apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
name: aws-secrets
spec:
provider: aws
parameters:
objects: |
- objectName: "arn:aws:secretsmanager:us-east-2:777788889999:secret:MySecret2-d4e5f6"
- objectName: "MySecret3"
objectType: "secretsmanager"
- objectName: "MySecret4"
objectType: "secretsmanager"
objectVersionLabel: "AWSCURRENT"
```
#### Contoh: Pasang pasangan nilai kunci dari rahasia
Contoh ini menunjukkan cara memasang pasangan nilai kunci tertentu dari rahasia berformat JSON:
```
apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
name: aws-secrets
spec:
provider: aws
parameters:
objects: |
- objectName: "arn:aws:secretsmanager:us-east-2:777788889999:secret:MySecret-a1b2c3"
jmesPath:
- path: username
objectAlias: dbusername
- path: password
objectAlias: dbpassword
```
#### Contoh: Pasang rahasia dengan izin file
Contoh ini menunjukkan cara memasang rahasia dengan izin file tertentu
```
apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
name: aws-secrets
spec:
provider: aws
parameters:
objects: |
- objectName: "mySecret"
objectType: "secretsmanager"
filePermission: "0600"
jmesPath:
- path: username
objectAlias: dbusername
filePermission: "0400"
```
#### Contoh: Contoh konfigurasi Failover
Contoh-contoh ini menunjukkan cara mengkonfigurasi failover untuk rahasia.
##### Kegagalan rahasia Multi-Wilayah
Contoh ini menunjukkan cara mengonfigurasi failover otomatis untuk rahasia yang direplikasi di beberapa Wilayah:
```
apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
name: aws-secrets
spec:
provider: aws
parameters:
region: us-east-1
failoverRegion: us-east-2
objects: |
- objectName: "MySecret"
```
##### Kegagalan ke rahasia yang berbeda
Contoh ini menunjukkan cara mengonfigurasi failover ke rahasia yang berbeda (bukan replika):
```
apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
name: aws-secrets
spec:
provider: aws
parameters:
region: us-east-1
failoverRegion: us-east-2
objects: |
- objectName: "arn:aws:secretsmanager:us-east-1:777788889999:secret:MySecret-a1b2c3"
objectAlias: "MyMountedSecret"
failoverObject:
- objectName: "arn:aws:secretsmanager:us-east-2:777788889999:secret:MyFailoverSecret-d4e5f6"
```
## Sumber daya tambahan
Untuk informasi selengkapnya tentang penggunaan ASCP dengan Amazon EKS, lihat sumber daya berikut:
+ [Menggunakan Identitas Pod dengan Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/pod-identities.html)
+ [Menggunakan Penyedia AWS Rahasia dan Konfigurasi](https://docs.aws.amazon.com/secretsmanager/latest/userguide/integrating_ascp_csi.html)
+ [AWS Secrets Store CSI Driver di GitHub](https://github.com/aws/secrets-store-csi-driver-provider-aws)
# Gunakan AWS Secrets Manager rahasia dalam AWS Lambda fungsi
AWS Lambda adalah layanan komputasi tanpa server yang memungkinkan Anda menjalankan kode tanpa menyediakan atau mengelola server. Parameter Store, kemampuan AWS Systems Manager, menyediakan penyimpanan hierarkis yang aman untuk manajemen data konfigurasi dan manajemen rahasia. Anda dapat menggunakan AWS Parameter dan Rahasia Lambda Extension untuk mengambil dan menyimpan AWS Secrets Manager rahasia dan parameter Parameter Store dalam fungsi Lambda tanpa menggunakan SDK. Untuk informasi mendetail tentang penggunaan ekstensi ini, lihat [Menggunakan rahasia Secrets Manager di fungsi Lambda](https://docs.aws.amazon.com/lambda/latest/dg/with-secrets-manager.html) di Panduan Pengembang *Lambda*.
## Menggunakan rahasia Secrets Manager dengan Lambda
Panduan Pengembang Lambda memberikan instruksi komprehensif untuk menggunakan rahasia Secrets Manager dalam fungsi Lambda. Untuk memulai:
1. Ikuti step-by-step tutorial di [Use Secrets Manager rahasia dalam fungsi Lambda](https://docs.aws.amazon.com/lambda/latest/dg/with-secrets-manager.html), yang meliputi:
+ Membuat fungsi Lambda dengan runtime pilihan Anda (Python, Node.js, Java)
+ Menambahkan AWS Parameter dan Rahasia Ekstensi Lambda sebagai lapisan
+ Mengkonfigurasi izin yang diperlukan
+ Menulis kode untuk mengambil rahasia dari ekstensi
+ Menguji fungsi Anda
1. Pelajari tentang variabel lingkungan untuk mengonfigurasi perilaku ekstensi, termasuk pengaturan cache dan batas waktu
1. Memahami praktik terbaik untuk bekerja dengan rotasi rahasia
### Menggunakan Secrets Manager dan Lambda di VPC
Jika fungsi Lambda Anda berjalan di VPC, Anda perlu membuat titik akhir VPC sehingga ekstensi dapat melakukan panggilan ke Secrets Manager. Untuk informasi selengkapnya, lihat [Menggunakan titik akhir AWS Secrets Manager VPC](vpc-endpoint-overview.md).
## Menggunakan AWS Parameter dan Rahasia Ekstensi Lambda
Ekstensi dapat mengambil rahasia Secrets Manager dan parameter Parameter Store. Untuk informasi rinci tentang penggunaan parameter Parameter Store dengan ekstensi, lihat [Menggunakan parameter Parameter Menyimpan dalam fungsi Lambda](https://docs.aws.amazon.com/systems-manager/latest/userguide/ps-integration-lambda-extensions.html) di *AWS Systems Manager Panduan Pengguna*.
Dokumentasi Systems Manager meliputi:
+ Penjelasan terperinci tentang cara kerja ekstensi dengan Parameter Store
+ Petunjuk untuk menambahkan ekstensi ke fungsi Lambda
+ Variabel lingkungan untuk mengkonfigurasi ekstensi
+ Contoh perintah untuk mengambil parameter
+ Daftar lengkap ekstensi ARNs untuk semua arsitektur dan wilayah yang didukung
# Menggunakan AWS Secrets Manager Agen
## Bagaimana Agen Secrets Manager bekerja
AWS Secrets Manager Agen adalah layanan HTTP sisi klien yang membantu Anda menstandarisasi cara Anda menggunakan rahasia dari Secrets Manager di seluruh lingkungan komputasi Anda. Anda dapat menggunakannya dengan layanan berikut:
+ AWS Lambda
+ Amazon Elastic Container Service
+ Amazon Elastic Kubernetes Service
+ Amazon Elastic Compute Cloud
Secrets Manager Agent mengambil dan menyimpan rahasia di memori, memungkinkan aplikasi Anda mendapatkan rahasia dari localhost alih-alih melakukan panggilan langsung ke Secrets Manager. Secrets Manager Agent hanya dapat membaca rahasia—tidak dapat memodifikasinya.
**penting**
Secrets Manager Agent menggunakan AWS kredensyal dari lingkungan Anda untuk memanggil Secrets Manager. Ini termasuk perlindungan terhadap Server Side Request Forgery (SSRF) untuk membantu meningkatkan keamanan rahasia. Secrets Manager Agent menggunakan pertukaran kunci ML-KEM pasca-kuantum sebagai pertukaran kunci prioritas tertinggi secara default.
## Memahami caching Agen Secrets Manager
Secrets Manager Agent menggunakan cache dalam memori yang disetel ulang saat Agen Secrets Manager dimulai ulang. Ini secara berkala menyegarkan nilai rahasia yang di-cache berdasarkan hal berikut:
+ Frekuensi refresh default (TTL) adalah 300 detik
+ Anda dapat memodifikasi TTL menggunakan file konfigurasi
+ Penyegaran terjadi saat Anda meminta rahasia setelah TTL kedaluwarsa
**catatan**
Secrets Manager Agent tidak menyertakan pembatalan cache. Jika rahasia berputar sebelum entri cache kedaluwarsa, Agen Secrets Manager mungkin mengembalikan nilai rahasia basi.
Secrets Manager Agent mengembalikan nilai rahasia dalam format yang sama dengan respons`GetSecretValue`. Nilai rahasia tidak dienkripsi dalam cache.
**Topics**
+ [Bagaimana Agen Secrets Manager bekerja](#agent-overview)
+ [Memahami caching Agen Secrets Manager](#agent-caching)
+ [Membangun Agen Secrets Manager](#secrets-manager-agent-build)
+ [Instal Agen Secrets Manager](#secrets-manager-agent-install)
+ [Ambil rahasia dengan Agen Secrets Manager](#secrets-manager-agent-call)
+ [Memahami `refreshNow` parameter](#secrets-manager-agent-refresh)
+ [Konfigurasikan Agen Secrets Manager](#secrets-manager-agent-config)
+ [Fitur opsional](#secrets-manager-agent-features)
+ [Pencatatan log](#secrets-manager-agent-log)
+ [Pertimbangan keamanan](#secrets-manager-agent-security)
## Membangun Agen Secrets Manager
Sebelum Anda mulai, pastikan Anda memiliki alat pengembangan standar dan alat Rust yang diinstal untuk platform Anda.
**catatan**
Membangun agen dengan `fips` fitur yang diaktifkan di macOS saat ini memerlukan solusi berikut:
Buat variabel lingkungan `SDKROOT` yang disebut yang diatur ke hasil berjalan `xcrun --show-sdk-path`
------
#### [ RPM-based systems ]
**Untuk membangun sistem berbasis RPM**
1. Gunakan `install` skrip yang disediakan di repositori.
Skrip menghasilkan token SSRF acak saat startup dan menyimpannya dalam file. `/var/run/awssmatoken` Token dapat dibaca oleh `awssmatokenreader` grup yang dibuat oleh skrip penginstalan.
1. Untuk memungkinkan aplikasi Anda membaca file token, Anda perlu menambahkan akun pengguna yang dijalankan aplikasi Anda ke `awssmatokenreader` grup. Misalnya, Anda dapat memberikan izin untuk aplikasi Anda untuk membaca file token dengan perintah usermod berikut, di mana ** ID pengguna tempat aplikasi Anda berjalan.
```
sudo usermod -aG awssmatokenreader
```
**Instal alat pengembangan**
Pada sistem berbasis RPM seperti AL2023, instal grup Alat Pengembangan:
```
sudo yum -y groupinstall "Development Tools"
```
1.
**Instal Rust**
Ikuti instruksi di [Install Rust](https://www.rust-lang.org/tools/install) dalam *dokumentasi Rust*:
```
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh # Follow the on-screen instructions
. "$HOME/.cargo/env"
```
1.
**Bangun agen**
Bangun Agen Secrets Manager menggunakan perintah cargo build:
```
cargo build --release
```
Anda akan menemukan executable di bawah. `target/release/aws_secretsmanager_agent`
------
#### [ Debian-based systems ]
**Untuk membangun sistem berbasis Debian**
1.
**Instal alat pengembangan**
Pada sistem berbasis Debian seperti Ubuntu, instal paket build-essential:
```
sudo apt install build-essential
```
1.
**Instal Rust**
Ikuti instruksi di [Install Rust](https://www.rust-lang.org/tools/install) dalam *dokumentasi Rust*:
```
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh # Follow the on-screen instructions
. "$HOME/.cargo/env"
```
1.
**Bangun agen**
Bangun Agen Secrets Manager menggunakan perintah cargo build:
```
cargo build --release
```
Anda akan menemukan executable di bawah. `target/release/aws_secretsmanager_agent`
------
#### [ Windows ]
**Untuk membangun pada Windows**
1.
**Menyiapkan lingkungan pengembangan**
Ikuti petunjuk di [Siapkan lingkungan dev Anda di Windows for Rust](https://learn.microsoft.com/en-us/windows/dev-environment/rust/setup) dalam *dokumentasi Microsoft Windows*.
1.
**Bangun agen**
Bangun Agen Secrets Manager menggunakan perintah cargo build:
```
cargo build --release
```
Anda akan menemukan executable di bawah. `target/release/aws_secretsmanager_agent.exe`
------
#### [ Cross-compile natively ]
**Untuk mengkompilasi silang secara asli**
1.
**Instal alat kompilasi silang**
Pada distribusi di mana paket mingw-w64 tersedia seperti Ubuntu, instal rantai alat kompilasi silang:
```
# Install the cross compile tool chain
sudo add-apt-repository universe
sudo apt install -y mingw-w64
```
1.
**Tambahkan target build Rust**
Instal target build Windows GNU:
```
rustup target add x86_64-pc-windows-gnu
```
1.
**Membangun untuk Windows**
Kompilasi silang agen untuk Windows:
```
cargo build --release --target x86_64-pc-windows-gnu
```
Anda akan menemukan executable di. `target/x86_64-pc-windows-gnu/release/aws_secretsmanager_agent.exe`
------
#### [ Cross compile with Rust cross ]
**Untuk mengkompilasi silang menggunakan Rust cross**
Jika alat kompilasi silang tidak tersedia secara asli di sistem, Anda dapat menggunakan proyek silang Rust. Untuk informasi lebih lanjut, lihat [https://github.com/cross-rs/silang](https://github.com/cross-rs/cross).
**penting**
Kami merekomendasikan ruang disk 32GB untuk lingkungan build.
1.
**Siapkan Docker**
Instal dan konfigurasikan Docker:
```
# Install and start docker
sudo yum -y install docker
sudo systemctl start docker
sudo systemctl enable docker # Make docker start after reboot
```
1.
**Konfigurasikan izin Docker**
Tambahkan pengguna Anda ke grup docker:
```
# Give ourselves permission to run the docker images without sudo
sudo usermod -aG docker $USER
newgrp docker
```
1.
**Membangun untuk Windows**
Instal silang dan buat executable:
```
# Install cross and cross compile the executable
cargo install cross
cross build --release --target x86_64-pc-windows-gnu
```
------
## Instal Agen Secrets Manager
Pilih lingkungan komputasi Anda dari opsi penginstalan berikut.
------
#### [ Amazon EC2 ]
**Untuk menginstal Agen Secrets Manager di Amazon EC2**
1.
**Arahkan ke direktori konfigurasi**
Ubah ke direktori konfigurasi:
```
cd aws_secretsmanager_agent/configuration
```
1.
**Jalankan skrip instalasi**
Jalankan `install` skrip yang disediakan di repositori.
Skrip menghasilkan token SSRF acak saat startup dan menyimpannya dalam file. `/var/run/awssmatoken` Token dapat dibaca oleh `awssmatokenreader` grup yang dibuat oleh skrip penginstalan.
1.
**Konfigurasikan izin aplikasi**
Tambahkan akun pengguna yang dijalankan aplikasi Anda ke `awssmatokenreader` grup:
```
sudo usermod -aG awssmatokenreader APP_USER
```
Ganti *APP\$1USER* dengan ID pengguna tempat aplikasi Anda berjalan.
------
#### [ Container Sidecar ]
Anda dapat menjalankan Secrets Manager Agent sebagai wadah sespan bersama aplikasi Anda dengan menggunakan Docker. Kemudian aplikasi Anda dapat mengambil rahasia dari server HTTP lokal yang disediakan Secrets Manager Agent. Untuk informasi tentang Docker, lihat [dokumentasi Docker](https://docs.docker.com).
**Untuk membuat wadah sespan untuk Agen Secrets Manager**
1.
**Buat agen Dockerfile**
Buat Dockerfile untuk wadah sidecar Secrets Manager Agent:
```
# Use the latest Debian image as the base
FROM debian:latest
# Set the working directory inside the container
WORKDIR /app
# Copy the Secrets Manager Agent binary to the container
COPY secrets-manager-agent .
# Install any necessary dependencies
RUN apt-get update && apt-get install -y ca-certificates
# Set the entry point to run the Secrets Manager Agent binary
ENTRYPOINT ["./secrets-manager-agent"]
```
1.
**Buat aplikasi Dockerfile**
Buat Dockerfile untuk aplikasi klien Anda.
1.
**Buat file Docker Compose**
Buat file Docker Compose untuk menjalankan kedua container dengan antarmuka jaringan bersama:
**penting**
Anda harus memuat AWS kredensyal dan token SSRF agar aplikasi dapat menggunakan Secrets Manager Agent. Untuk Amazon EKS dan Amazon ECS, lihat yang berikut ini:
[Mengelola akses](https://docs.aws.amazon.com/eks/latest/userguide/cluster-auth.html) di *Panduan Pengguna Amazon EKS*
[Peran IAM tugas Amazon ECS dalam Panduan](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html) Pengembang *Amazon ECS*
```
version: '3'
services:
client-application:
container_name: client-application
build:
context: .
dockerfile: Dockerfile.client
command: tail -f /dev/null # Keep the container running
secrets-manager-agent:
container_name: secrets-manager-agent
build:
context: .
dockerfile: Dockerfile.agent
network_mode: "container:client-application" # Attach to the client-application container's network
depends_on:
- client-application
```
1.
**Salin agen biner**
Salin `secrets-manager-agent` biner ke direktori yang sama yang berisi file Dockerfiles dan Docker Compose Anda.
1.
**Membangun dan menjalankan kontainer**
Buat dan jalankan container menggunakan Docker Compose:
```
docker-compose up --build
```
1.
**Langkah selanjutnya**
Anda sekarang dapat menggunakan Secrets Manager Agent untuk mengambil rahasia dari wadah klien Anda. Untuk informasi selengkapnya, lihat [Ambil rahasia dengan Agen Secrets Manager](#secrets-manager-agent-call).
------
#### [ Lambda ]
Anda dapat [mengemas Agen Secrets Manager sebagai ekstensi Lambda](https://docs.aws.amazon.com/lambda/latest/dg/packaging-layers.html). Kemudian Anda dapat [menambahkannya ke fungsi Lambda Anda sebagai lapisan](https://docs.aws.amazon.com/lambda/latest/dg/adding-layers.html) dan memanggil Secrets Manager Agent dari fungsi Lambda Anda untuk mendapatkan rahasia.
Petunjuk berikut menunjukkan cara mendapatkan rahasia bernama *MyTest*dengan menggunakan skrip `secrets-manager-agent-extension.sh` contoh [https://github.com/aws/aws-secretsmanager-agent](https://github.com/aws/aws-secretsmanager-agent)untuk menginstal Secrets Manager Agent sebagai ekstensi Lambda.
**Untuk membuat ekstensi Lambda untuk Agen Secrets Manager**
1.
**Package lapisan agen**
Dari root paket kode Agen Secrets Manager, jalankan perintah berikut:
```
AWS_ACCOUNT_ID=AWS_ACCOUNT_ID
LAMBDA_ARN=LAMBDA_ARN
# Build the release binary
cargo build --release --target=x86_64-unknown-linux-gnu
# Copy the release binary into the `bin` folder
mkdir -p ./bin
cp ./target/x86_64-unknown-linux-gnu/release/aws_secretsmanager_agent ./bin/secrets-manager-agent
# Copy the `secrets-manager-agent-extension.sh` example script into the `extensions` folder.
mkdir -p ./extensions
cp aws_secretsmanager_agent/examples/example-lambda-extension/secrets-manager-agent-extension.sh ./extensions
# Zip the extension shell script and the binary
zip secrets-manager-agent-extension.zip bin/* extensions/*
# Publish the layer version
LAYER_VERSION_ARN=$(aws lambda publish-layer-version \
--layer-name secrets-manager-agent-extension \
--zip-file "fileb://secrets-manager-agent-extension.zip" | jq -r '.LayerVersionArn')
```
1.
**Konfigurasikan token SSRF**
Konfigurasi default agen akan secara otomatis mengatur token SSRF ke nilai yang ditetapkan dalam variabel pra-set `AWS_SESSION_TOKEN` atau `AWS_CONTAINER_AUTHORIZATION_TOKEN` lingkungan (variabel terakhir untuk fungsi Lambda dengan diaktifkan). SnapStart Atau, Anda dapat menentukan variabel `AWS_TOKEN` lingkungan dengan nilai arbitrer untuk fungsi Lambda Anda sebagai gantinya karena variabel ini lebih diutamakan daripada dua lainnya. Jika Anda memilih untuk menggunakan variabel `AWS_TOKEN` lingkungan, Anda harus mengatur variabel lingkungan dengan `lambda:UpdateFunctionConfiguration` panggilan.
1.
**Pasang lapisan ke fungsi**
Lampirkan versi layer ke fungsi Lambda Anda:
```
# Attach the layer version to the Lambda function
aws lambda update-function-configuration \
--function-name $LAMBDA_ARN \
--layers "$LAYER_VERSION_ARN"
```
1.
**Perbarui kode fungsi**
Perbarui fungsi Lambda Anda untuk melakukan kueri `http://localhost:2773/secretsmanager/get?secretId=MyTest` dengan nilai `X-Aws-codes-Secrets-Token` header yang disetel ke nilai token SSRF yang bersumber dari salah satu variabel lingkungan yang disebutkan di atas untuk mengambil rahasia. Pastikan untuk menerapkan logika coba lagi dalam kode aplikasi Anda untuk mengakomodasi penundaan inisialisasi dan pendaftaran ekstensi Lambda.
1.
**Uji fungsi**
Memanggil fungsi Lambda untuk memverifikasi bahwa rahasia sedang diambil dengan benar.
------
## Ambil rahasia dengan Agen Secrets Manager
Untuk mengambil rahasia, hubungi titik akhir Secrets Manager Agent lokal dengan nama rahasia atau ARN sebagai parameter kueri. Secara default, Secrets Manager Agent mengambil `AWSCURRENT` versi rahasia. Untuk mengambil versi yang berbeda, gunakan parameter versionStage atau VersionId.
**penting**
Untuk membantu melindungi Agen Secrets Manager, Anda harus menyertakan header token SSRF sebagai bagian dari setiap permintaan:. `X-Aws-Parameters-Secrets-Token` Secrets Manager Agent menolak permintaan yang tidak memiliki header ini atau yang memiliki token SSRF tidak valid. Anda dapat menyesuaikan nama header SSRF di file. [Konfigurasikan Agen Secrets Manager](#secrets-manager-agent-config)
### Izin yang diperlukan
Secrets Manager Agent menggunakan AWS SDK for Rust, yang menggunakan rantai [penyedia AWS kredensyal](https://docs.aws.amazon.com/sdk-for-rust/latest/dg/credentials.html). Identitas kredensyal IAM ini menentukan izin yang dimiliki Agen Secrets Manager untuk mengambil rahasia.
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`
Untuk informasi selengkapnya tentang izin, lihat [Referensi izin untuk AWS Secrets Manager](auth-and-access.md#reference_iam-permissions).
**penting**
Setelah nilai rahasia ditarik ke Secrets Manager Agent, setiap pengguna dengan akses ke lingkungan komputasi dan token SSRF dapat mengakses rahasia dari cache Secrets Manager Agent. Untuk informasi selengkapnya, lihat [Pertimbangan keamanan](#secrets-manager-agent-security).
### Permintaan contoh
------
#### [ curl ]
**Example Contoh - Dapatkan rahasia menggunakan curl**
Contoh curl berikut menunjukkan cara mendapatkan rahasia dari Secrets Manager Agent. Contohnya bergantung pada SSRF yang ada dalam file, yang mana ia disimpan oleh skrip instalasi.
```
curl -v -H \\
"X-Aws-Parameters-Secrets-Token: $(/var/run/awssmatoken)" \\
'http://localhost:2773/secretsmanager/get?secretId=YOUR_SECRET_ID' \\
echo
```
------
#### [ Python ]
**Example Contoh - Dapatkan rahasia menggunakan Python**
Contoh Python berikut menunjukkan cara mendapatkan rahasia dari Secrets Manager Agent. Contohnya bergantung pada SSRF yang ada dalam file, yang mana ia disimpan oleh skrip instalasi.
```
import requests
import json
# Function that fetches the secret from Secrets Manager Agent for the provided secret id.
def get_secret():
# Construct the URL for the GET request
url = f"http://localhost:2773/secretsmanager/get?secretId=YOUR_SECRET_ID"
# Get the SSRF token from the token file
with open('/var/run/awssmatoken') as fp:
token = fp.read()
headers = {
"X-Aws-Parameters-Secrets-Token": token.strip()
}
try:
# Send the GET request with headers
response = requests.get(url, headers=headers)
# Check if the request was successful
if response.status_code == 200:
# Return the secret value
return response.text
else:
# Handle error cases
raise Exception(f"Status code {response.status_code} - {response.text}")
except Exception as e:
# Handle network errors
raise Exception(f"Error: {e}")
```
------
## Memahami `refreshNow` parameter
Secrets Manager Agent menggunakan cache dalam memori untuk menyimpan nilai rahasia, yang disegarkan secara berkala. Secara default, penyegaran ini terjadi ketika Anda meminta rahasia setelah Time to Live (TTL) kedaluwarsa, biasanya setiap 300 detik. Namun, pendekatan ini terkadang dapat menghasilkan nilai rahasia basi, terutama jika rahasia berputar sebelum entri cache kedaluwarsa.
Untuk mengatasi batasan ini, Secrets Manager Agent mendukung parameter yang disebut `refreshNow` di URL. Anda dapat menggunakan parameter ini untuk memaksa penyegaran langsung nilai rahasia, melewati cache dan memastikan Anda memiliki up-to-date informasi terbanyak.
**Perilaku default (tanpa`refreshNow`)**
+ Menggunakan nilai cache sampai TTL kedaluwarsa
+ Menyegarkan rahasia hanya setelah TTL (default 300 detik)
+ Dapat mengembalikan nilai basi jika rahasia berputar sebelum cache kedaluwarsa
**Perilaku dengan `refreshNow=true`**
+ Melewati cache sepenuhnya
+ Mengambil nilai rahasia terbaru langsung dari Secrets Manager
+ Memperbarui cache dengan nilai segar dan mengatur ulang TTL
+ Memastikan Anda selalu mendapatkan nilai rahasia terbaru
### Segarkan paksa nilai rahasia
**penting**
Nilai default `refreshNow` adalah `false`. Ketika diatur ke`true`, itu akan mengganti TTL yang ditentukan dalam file konfigurasi Secrets Manager Agent dan membuat panggilan API ke Secrets Manager.
------
#### [ curl ]
**Example Contoh - Memaksa refresh rahasia menggunakan curl**
Contoh curl berikut menunjukkan cara memaksa Secrets Manager Agent untuk menyegarkan rahasia. Contohnya bergantung pada SSRF yang ada dalam file, yang mana ia disimpan oleh skrip instalasi.
```
curl -v -H \\
"X-Aws-Parameters-Secrets-Token: $(/var/run/awssmatoken)" \\
'http://localhost:2773/secretsmanager/get?secretId=YOUR_SECRET_ID&refreshNow=true' \\
echo
```
------
#### [ Python ]
**Example Contoh - Memaksa refresh rahasia menggunakan Python**
Contoh Python berikut menunjukkan cara mendapatkan rahasia dari Secrets Manager Agent. Contohnya bergantung pada SSRF yang ada dalam file, yang mana ia disimpan oleh skrip instalasi.
```
import requests
import json
# Function that fetches the secret from Secrets Manager Agent for the provided secret id.
def get_secret():
# Construct the URL for the GET request
url = f"http://localhost:2773/secretsmanager/get?secretId=YOUR_SECRET_ID&refreshNow=true"
# Get the SSRF token from the token file
with open('/var/run/awssmatoken') as fp:
token = fp.read()
headers = {
"X-Aws-Parameters-Secrets-Token": token.strip()
}
try:
# Send the GET request with headers
response = requests.get(url, headers=headers)
# Check if the request was successful
if response.status_code == 200:
# Return the secret value
return response.text
else:
# Handle error cases
raise Exception(f"Status code {response.status_code} - {response.text}")
except Exception as e:
# Handle network errors
raise Exception(f"Error: {e}")
```
------
## Konfigurasikan Agen Secrets Manager
Untuk mengubah konfigurasi Secrets Manager Agent, buat file konfigurasi [TOMB](https://toml.io/en/), lalu panggil. `./aws_secretsmanager_agent --config config.toml`Opsi konfigurasi
**`log_level`**
Tingkat detail yang dilaporkan dalam log untuk Secrets Manager Agent: DEBUG, INFO, WARN, ERROR, atau NONE. Defaultnya adalah INFO.
**`log_to_file`**
Apakah akan masuk ke file atau stdout/stderr: atau. `true` `false` Nilai default-nya `true`.
**`http_port`**
Port untuk server HTTP lokal, dalam kisaran 1024 hingga 65535. Defaultnya adalah 2773.
**`region`**
AWS Wilayah yang akan digunakan untuk permintaan. Jika tidak ada Region yang ditentukan, Secrets Manager Agent menentukan Region dari SDK. Untuk informasi selengkapnya, lihat [Menentukan kredensil dan Wilayah default Anda](https://docs.aws.amazon.com/sdk-for-rust/latest/dg/credentials.html) di *AWS SDK for Rust* Developer Guide.
**`ttl_seconds`**
TTL dalam hitungan detik untuk item yang di-cache, dalam kisaran 0 hingga 3600. Defaultnya adalah 300. 0 menunjukkan bahwa tidak ada caching.
**`cache_size`**
Jumlah maksimum rahasia yang dapat disimpan dalam cache, dalam kisaran 1 hingga 1000. Defaultnya adalah 1000.
**`ssrf_headers`**
Daftar nama header Secrets Manager Agent memeriksa token SSRF. Defaultnya adalah “X-Aws-Parameters-Secrets-Token,”. X-Vault-Token
**`ssrf_env_variables`**
Daftar nama variabel lingkungan yang diperiksa Agen Secrets Manager secara berurutan untuk token SSRF. Variabel lingkungan dapat berisi token atau referensi ke file token seperti pada:`AWS_TOKEN=file:///var/run/awssmatoken`. Standarnya adalah "AWS\$1TOKEN, AWS\$1SESSION \$1TOKEN, AWS\$1CONTAINER \$1AUTHORIZATION\$1TOKEN”.
**`path_prefix`**
Awalan URI digunakan untuk menentukan apakah permintaan adalah permintaan berbasis jalur. Defaultnya adalah “/v1/”.
**`max_conn`**
Jumlah maksimum koneksi dari klien HTTP yang diizinkan oleh Agen Secrets Manager, dalam kisaran 1 hingga 1000. Defaultnya adalah 800.
## Fitur opsional
Secrets Manager Agent dapat dibangun dengan fitur opsional dengan meneruskan `--features` bendera ke`cargo build`. Fitur yang tersedia adalah:Membangun fitur
**`prefer-post-quantum`**
Membuat `X25519MLKEM768` algoritma pertukaran kunci prioritas tertinggi. Jika tidak, itu tersedia tetapi tidak prioritas tertinggi. `X25519MLKEM768`adalah algoritma pertukaran post-quantum-secure kunci hibrida.
**`fips`**
Membatasi cipher suite yang digunakan oleh agen hanya untuk cipher yang disetujui FIPS.
## Pencatatan log
**Penebangan lokal**
Secrets Manager Agent mencatat kesalahan secara lokal ke file `logs/secrets_manager_agent.log` atau ke stdout/stderr tergantung pada variabel konfigurasi. `log_to_file` Ketika aplikasi Anda memanggil Agen Secrets Manager untuk mendapatkan rahasia, panggilan tersebut muncul di log lokal. Mereka tidak muncul di CloudTrail log.
**Rotasi log**
Secrets Manager Agent membuat file log baru ketika file mencapai 10 MB, dan menyimpan hingga lima file log total.
**AWS layanan logging**
Log tidak masuk ke Secrets Manager, CloudTrail, atau CloudWatch. Permintaan untuk mendapatkan rahasia dari Agen Secrets Manager tidak muncul di log tersebut. Ketika Agen Secrets Manager melakukan panggilan ke Secrets Manager untuk mendapatkan rahasia, panggilan itu direkam CloudTrail dengan string agen pengguna yang berisi`aws-secrets-manager-agent`.
Anda dapat mengonfigurasi opsi logging di file[Konfigurasikan Agen Secrets Manager](#secrets-manager-agent-config).
## Pertimbangan keamanan
**Domain kepercayaan**
Untuk arsitektur agen, domain kepercayaan adalah tempat titik akhir agen dan token SSRF dapat diakses, yang biasanya merupakan seluruh host. Domain kepercayaan untuk Agen Secrets Manager harus sesuai dengan domain tempat kredensi Secrets Manager tersedia untuk mempertahankan postur keamanan yang sama. Misalnya, di Amazon EC2 domain kepercayaan untuk Agen Secrets Manager akan sama dengan domain kredensil saat menggunakan peran untuk Amazon EC2.
**penting**
Aplikasi sadar keamanan yang belum menggunakan solusi agen dengan kredenal Secrets Manager yang dikunci ke aplikasi harus mempertimbangkan untuk menggunakan solusi khusus bahasa AWS SDKs atau caching. Untuk informasi selengkapnya, lihat [Mendapatkan rahasia](https://docs.aws.amazon.com/secretsmanager/latest/userguide/retrieving-secrets.html).
# Dapatkan nilai rahasia Secrets Manager menggunakan C\$1\$1 SDK AWS
Untuk aplikasi C\$1\$1, hubungi SDK secara langsung dengan [GetSecretValue](https://docs.aws.amazon.com/goto/SdkForCpp/secretsmanager-2017-10-17/GetSecretValue)atau. [BatchGetSecretValue](https://docs.aws.amazon.com/goto/SdkForCpp/secretsmanager-2017-10-17/BatchGetSecretValue)
Contoh kode berikut menunjukkan cara mendapatkan nilai rahasia Secrets Manager.
**Izin yang diperlukan:** `secretsmanager:GetSecretValue`
```
//! Retrieve an AWS Secrets Manager encrypted secret.
/*!
\param secretID: The ID for the secret.
\return bool: Function succeeded.
*/
bool AwsDoc::SecretsManager::getSecretValue(const Aws::String &secretID,
const Aws::Client::ClientConfiguration &clientConfiguration) {
Aws::SecretsManager::SecretsManagerClient secretsManagerClient(clientConfiguration);
Aws::SecretsManager::Model::GetSecretValueRequest request;
request.SetSecretId(secretID);
Aws::SecretsManager::Model::GetSecretValueOutcome getSecretValueOutcome = secretsManagerClient.GetSecretValue(
request);
if (getSecretValueOutcome.IsSuccess()) {
std::cout << "Secret is: "
<< getSecretValueOutcome.GetResult().GetSecretString() << std::endl;
}
else {
std::cerr << "Failed with Error: " << getSecretValueOutcome.GetError()
<< std::endl;
}
return getSecretValueOutcome.IsSuccess();
}
```
# Dapatkan nilai rahasia Secrets Manager menggunakan JavaScript AWS SDK
Untuk JavaScript aplikasi, hubungi SDK secara langsung dengan [https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/SecretsManager.html#getSecretValue-property](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/SecretsManager.html#getSecretValue-property)atau [https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/SecretsManager.html#batchGetSecretValue-property](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/SecretsManager.html#batchGetSecretValue-property).
Contoh kode berikut menunjukkan cara mendapatkan nilai rahasia Secrets Manager.
**Izin yang diperlukan:** `secretsmanager:GetSecretValue`
```
import {
GetSecretValueCommand,
SecretsManagerClient,
} from "@aws-sdk/client-secrets-manager";
export const getSecretValue = async (secretName = "SECRET_NAME") => {
const client = new SecretsManagerClient();
const response = await client.send(
new GetSecretValueCommand({
SecretId: secretName,
}),
);
console.log(response);
// {
// '$metadata': {
// httpStatusCode: 200,
// requestId: '584eb612-f8b0-48c9-855e-6d246461b604',
// extendedRequestId: undefined,
// cfId: undefined,
// attempts: 1,
// totalRetryDelay: 0
// },
// ARN: 'arn:aws:secretsmanager:us-east-1:xxxxxxxxxxxx:secret:binary-secret-3873048-xxxxxx',
// CreatedDate: 2023-08-08T19:29:51.294Z,
// Name: 'binary-secret-3873048',
// SecretBinary: Uint8Array(11) [
// 98, 105, 110, 97, 114,
// 121, 32, 100, 97, 116,
// 97
// ],
// VersionId: '712083f4-0d26-415e-8044-16735142cd6a',
// VersionStages: [ 'AWSCURRENT' ]
// }
if (response.SecretString) {
return response.SecretString;
}
if (response.SecretBinary) {
return response.SecretBinary;
}
};
```
# Dapatkan nilai rahasia Secrets Manager menggunakan Kotlin AWS SDK
Untuk aplikasi Kotlin, hubungi SDK secara langsung dengan [GetSecretValue](https://github.com/awslabs/aws-sdk-kotlin#generating-api-documentation)atau. [BatchGetSecretValue](https://github.com/awslabs/aws-sdk-kotlin#generating-api-documentation)
Contoh kode berikut menunjukkan cara mendapatkan nilai rahasia Secrets Manager.
**Izin yang diperlukan:** `secretsmanager:GetSecretValue`
```
suspend fun getValue(secretName: String?) {
val valueRequest =
GetSecretValueRequest {
secretId = secretName
}
SecretsManagerClient.fromEnvironment { region = "us-east-1" }.use { secretsClient ->
val response = secretsClient.getSecretValue(valueRequest)
val secret = response.secretString
println("The secret value is $secret")
}
}
```
# Dapatkan nilai rahasia Secrets Manager menggunakan PHP AWS SDK
Untuk aplikasi PHP, hubungi SDK langsung dengan [https://docs.aws.amazon.com//aws-sdk-php/v3/api/api-secretsmanager-2017-10-17.html#getsecretvalue](https://docs.aws.amazon.com//aws-sdk-php/v3/api/api-secretsmanager-2017-10-17.html#getsecretvalue)atau [https://docs.aws.amazon.com//aws-sdk-php/v3/api/api-secretsmanager-2017-10-17.html#batchGetsecretvalue](https://docs.aws.amazon.com//aws-sdk-php/v3/api/api-secretsmanager-2017-10-17.html#batchGetsecretvalue).
Contoh kode berikut menunjukkan cara mendapatkan nilai rahasia Secrets Manager.
**Izin yang diperlukan:** `secretsmanager:GetSecretValue`
```
>/sdk-for-php/v3/developer-guide/guide_credentials.html
*/
// Create a Secrets Manager Client
$client = new SecretsManagerClient([
'profile' => 'default',
'version' => '2017-10-17',
'region' => '<<{{MyRegionName}}>>',
]);
$secret_name = '<<{{MySecretName}}>>';
try {
$result = $client->getSecretValue([
'SecretId' => $secret_name,
]);
} catch (AwsException $e) {
// For a list of exceptions thrown, see
// https://<<{{DocsDomain}}>>/secretsmanager/latest/apireference/API_GetSecretValue.html
throw $e;
}
// Decrypts secret using the associated KMS key.
$secret = $result['SecretString'];
// Your code goes here
```
# Dapatkan nilai rahasia Secrets Manager menggunakan Ruby SDK AWS
Untuk aplikasi Ruby, hubungi SDK langsung dengan [https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/SecretsManager/Client.html#get_secret_value-instance_method](https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/SecretsManager/Client.html#get_secret_value-instance_method)atau. [https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/SecretsManager/Client.html#batch_get_secret_value-instance_method](https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/SecretsManager/Client.html#batch_get_secret_value-instance_method)
Contoh kode berikut menunjukkan cara mendapatkan nilai rahasia Secrets Manager.
**Izin yang diperlukan:** `secretsmanager:GetSecretValue`
```
# Use this code snippet in your app.
# If you need more information about configurations or implementing the sample code, visit the AWS docs:
# https://aws.amazon.com/developer/language/ruby/
require 'aws-sdk-secretsmanager'
def get_secret
client = Aws::SecretsManager::Client.new(region: '<<{{MyRegionName}}>>')
begin
get_secret_value_response = client.get_secret_value(secret_id: '<<{{MySecretName}}>>')
rescue StandardError => e
# For a list of exceptions thrown, see
# https://<<{{DocsDomain}}>>/secretsmanager/latest/apireference/API_GetSecretValue.html
raise e
end
secret = get_secret_value_response.secret_string
# Your code goes here.
end
```
# Dapatkan nilai rahasia menggunakan AWS CLI
**Izin yang diperlukan:** `secretsmanager:GetSecretValue`
**Example Ambil nilai rahasia terenkripsi dari sebuah rahasia**
[https://docs.aws.amazon.com//cli/latest/reference/secretsmanager/get-secret-value.html](https://docs.aws.amazon.com//cli/latest/reference/secretsmanager/get-secret-value.html)Contoh berikut mendapatkan nilai rahasia saat ini.
```
aws secretsmanager get-secret-value \
--secret-id MyTestSecret
```
**Example Ambil nilai rahasia sebelumnya**
[https://docs.aws.amazon.com//cli/latest/reference/secretsmanager/get-secret-value.html](https://docs.aws.amazon.com//cli/latest/reference/secretsmanager/get-secret-value.html)Contoh berikut mendapatkan nilai rahasia sebelumnya.
```
aws secretsmanager get-secret-value \
--secret-id MyTestSecret
--version-stage AWSPREVIOUS
```
## Dapatkan sekelompok rahasia dalam batch menggunakan AWS CLI
**Izin yang diperlukan:**
+ `secretsmanager:BatchGetSecretValue`
+ `secretsmanager:GetSecretValue`izin untuk setiap rahasia yang ingin Anda ambil.
+ Jika Anda menggunakan filter, Anda juga harus memilikinya`secretsmanager:ListSecrets`.
Untuk contoh kebijakan izin, lihat[Contoh: Izin untuk mengambil sekelompok nilai rahasia dalam batch](auth-and-access_iam-policies.md#auth-and-access_examples_batch).
**penting**
Jika Anda memiliki kebijakan VPCE yang menolak izin untuk mengambil rahasia individu dalam grup yang Anda ambil, tidak `BatchGetSecretValue` akan mengembalikan nilai rahasia apa pun, dan itu akan mengembalikan kesalahan.
**Example Ambil nilai rahasia untuk sekelompok rahasia yang terdaftar dengan nama**
[https://docs.aws.amazon.com//cli/latest/reference/secretsmanager/batch-get-secret-value.html](https://docs.aws.amazon.com//cli/latest/reference/secretsmanager/batch-get-secret-value.html)Contoh berikut mendapatkan nilai rahasia untuk tiga rahasia.
```
aws secretsmanager batch-get-secret-value \
--secret-id-list MySecret1 MySecret2 MySecret3
```
**Example Ambil nilai rahasia untuk sekelompok rahasia yang dipilih oleh filter**
[https://docs.aws.amazon.com//cli/latest/reference/secretsmanager/batch-get-secret-value.html](https://docs.aws.amazon.com//cli/latest/reference/secretsmanager/batch-get-secret-value.html)Contoh berikut mendapatkan nilai rahasia untuk rahasia yang memiliki tag bernama “Test”.
```
aws secretsmanager batch-get-secret-value \
--filters Key="tag-key",Values="Test"
```
# Dapatkan nilai rahasia menggunakan AWS konsol
**Untuk mengambil rahasia (konsol)**
1. Buka konsol Secrets Manager di [https://console.aws.amazon.com/secretsmanager/](https://console.aws.amazon.com/secretsmanager/).
1. Dalam daftar rahasia, pilih rahasia yang ingin Anda ambil.
1. Di bagian **Nilai rahasia**, pilih **Ambil nilai rahasia**.
Secrets Manager menampilkan versi saat ini (`AWSCURRENT`) dari rahasia. Untuk melihat [versi rahasia lainnya](whats-in-a-secret.md#term_version), seperti `AWSPREVIOUS` atau versi berlabel khusus, gunakan file. [Dapatkan nilai rahasia menggunakan AWS CLI](retrieving-secrets_cli.md)
# Gunakan AWS Secrets Manager rahasia di AWS Batch
AWS Batch membantu Anda menjalankan beban kerja komputasi batch di. AWS Cloud Dengan AWS Batch, Anda dapat menyuntikkan data sensitif ke dalam pekerjaan Anda dengan menyimpan data sensitif Anda dalam AWS Secrets Manager rahasia dan kemudian mereferensikannya dalam definisi pekerjaan Anda. Untuk informasi selengkapnya, lihat [Menentukan data sensitif menggunakan Secrets Manager](https://docs.aws.amazon.com/batch/latest/userguide/specifying-sensitive-data-secrets.html).
# Dapatkan AWS Secrets Manager rahasia di sumber CloudFormation daya
Dengan CloudFormation, Anda dapat mengambil rahasia untuk digunakan di CloudFormation sumber lain. Skenario umum adalah pertama-tama membuat rahasia dengan kata sandi yang dihasilkan oleh Secrets Manager, dan kemudian mengambil nama pengguna dan kata sandi dari rahasia untuk digunakan sebagai kredensyal untuk database baru. Untuk informasi tentang membuat rahasia dengan CloudFormation, lihat[Buat AWS Secrets Manager rahasia di AWS CloudFormation](cloudformation.md).
Untuk mengambil rahasia dalam CloudFormation template, Anda menggunakan *referensi dinamis*. Saat Anda membuat tumpukan, referensi dinamis menarik nilai rahasia ke CloudFormation sumber daya, sehingga Anda tidak perlu melakukan hardcode informasi rahasia. Sebaliknya, Anda merujuk ke rahasia dengan nama atau ARN. Anda dapat menggunakan referensi dinamis untuk rahasia di properti sumber daya apa pun. Anda tidak dapat menggunakan referensi dinamis untuk rahasia dalam metadata sumber daya seperti [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-init.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-init.html)karena itu akan membuat nilai rahasia terlihat di konsol.
Referensi dinamis untuk rahasia memiliki pola berikut:
```
{{resolve:secretsmanager:secret-id:SecretString:json-key:version-stage:version-id}}
```
**rahasia-id**
Nama atau ARN rahasianya. Untuk mengakses rahasia di AWS akun Anda, Anda dapat menggunakan nama rahasia. Untuk mengakses rahasia di AWS akun yang berbeda, gunakan ARN rahasia.
**json-key (Opsional**)
Nama kunci dari pasangan kunci-nilai yang nilainya ingin Anda ambil. Jika Anda tidak menentukan`json-key`, CloudFormation mengambil seluruh teks rahasia. Segmen ini mungkin tidak memasukkan karakter titik dua ( `:`).
**tahap versi (Opsional**)
[Versi](whats-in-a-secret.md#term_version) rahasia untuk digunakan. Secrets Manager menggunakan label pementasan untuk melacak versi yang berbeda selama proses rotasi. Jika Anda menggunakan `version-stage` maka jangan tentukan `version-id`. Jika Anda tidak menentukan salah satu `version-stage` atau`version-id`, maka defaultnya adalah `AWSCURRENT` versinya. Segmen ini mungkin tidak memasukkan karakter titik dua ( `:`).
**version-id (Opsional**)
Pengidentifikasi unik dari versi rahasia yang akan digunakan. Jika Anda menentukan `version-id`, jangan tentukan `version-stage`. Jika Anda tidak menentukan salah satu `version-stage` atau`version-id`, maka defaultnya adalah `AWSCURRENT` versinya. Segmen ini mungkin tidak memasukkan karakter titik dua ( `:`).
Untuk informasi selengkapnya, lihat [Menggunakan referensi dinamis untuk menentukan rahasia Secrets Manager](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/dynamic-references.html#dynamic-references-secretsmanager).
**catatan**
Jangan membuat referensi dinamis menggunakan garis miring terbalik `(\)` sebagai nilai akhir. CloudFormation tidak dapat menyelesaikan referensi tersebut, yang menyebabkan kegagalan sumber daya.
# Gunakan AWS Secrets Manager rahasia dalam GitHub pekerjaan
Untuk menggunakan rahasia dalam GitHub pekerjaan, Anda dapat menggunakan GitHub tindakan untuk mengambil rahasia dari AWS Secrets Manager dan menambahkannya sebagai [variabel Lingkungan](https://docs.github.com/en/actions/learn-github-actions/environment-variables) bertopeng dalam alur kerja Anda GitHub . Untuk informasi selengkapnya tentang GitHub Tindakan, lihat [Memahami GitHub Tindakan](https://docs.github.com/en/actions/learn-github-actions/understanding-github-actions) di *GitHub Dokumen.*
Ketika Anda menambahkan rahasia ke GitHub lingkungan Anda, itu tersedia untuk semua langkah lain dalam GitHub pekerjaan Anda. Ikuti panduan dalam [Pengerasan Keamanan untuk GitHub Tindakan](https://docs.github.com/en/actions/security-guides/security-hardening-for-github-actions) untuk membantu mencegah rahasia di lingkungan Anda disalahgunakan.
Anda dapat mengatur seluruh string dalam nilai rahasia sebagai nilai variabel lingkungan, atau jika string adalah JSON, Anda dapat mengurai JSON untuk mengatur variabel lingkungan individu untuk setiap pasangan nilai kunci JSON. Jika nilai rahasia adalah biner, tindakan mengubahnya menjadi string.
Untuk melihat variabel lingkungan yang dibuat dari rahasia Anda, aktifkan logging debug. *Untuk informasi selengkapnya, lihat [Mengaktifkan logging debug](https://docs.github.com/en/actions/monitoring-and-troubleshooting-workflows/enabling-debug-logging) di Dokumen. GitHub *
Untuk menggunakan variabel lingkungan yang dibuat dari rahasia Anda, lihat [Variabel lingkungan](https://docs.github.com/en/actions/learn-github-actions/environment-variables) di *GitHub Dokumen.*
## Prasyarat
Untuk menggunakan tindakan ini, Anda harus terlebih dahulu mengonfigurasi AWS kredensil dan mengatur Wilayah AWS di GitHub lingkungan Anda dengan menggunakan langkah tersebut`configure-aws-credentials`. Ikuti petunjuk di [Mengonfigurasi Tindakan AWS Kredensial Untuk GitHub Tindakan untuk](https://github.com/aws-actions/configure-aws-credentials) **Mengasumsikan peran secara langsung menggunakan penyedia GitHub OIDC**. Ini memungkinkan Anda untuk menggunakan kredensil berumur pendek dan menghindari menyimpan kunci akses tambahan di luar Secrets Manager.
Peran IAM yang diasumsikan tindakan harus memiliki izin berikut:
+ `GetSecretValue`pada rahasia yang ingin Anda ambil.
+ `ListSecrets`pada semua rahasia.
+ (Opsional) `Decrypt` pada KMS key jika rahasia dienkripsi dengan file. kunci yang dikelola pelanggan
Untuk informasi selengkapnya, lihat [Otentikasi dan kontrol akses untuk AWS Secrets Manager](auth-and-access.md).
## Penggunaan
Untuk menggunakan tindakan, tambahkan langkah ke alur kerja Anda yang menggunakan sintaks berikut.
```
- name: Step name
uses: aws-actions/aws-secretsmanager-get-secrets@v2
with:
secret-ids: |
secretId1
ENV_VAR_NAME, secretId2
name-transformation: (Optional) uppercase|lowercase|none
parse-json-secrets: (Optional) true|false
```Parameter
`secret-ids`
Rahasia ARNS, nama, dan awalan nama.
Untuk mengatur nama variabel lingkungan, masukkan sebelum ID rahasia, diikuti dengan koma. Misalnya `ENV_VAR_1, secretId` membuat variabel lingkungan bernama **ENV\$1VAR\$11** dari rahasia. `secretId` Nama variabel lingkungan dapat terdiri dari huruf besar, angka, dan garis bawah.
Untuk menggunakan awalan, masukkan setidaknya tiga karakter diikuti dengan tanda bintang. Misalnya `dev*` mencocokkan semua rahasia dengan nama yang dimulai di **dev**. Jumlah maksimum rahasia pencocokan yang dapat diambil adalah 100. Jika Anda menetapkan nama variabel, dan awalan cocok dengan beberapa rahasia, maka tindakan gagal.
`name-transformation`
Secara default, langkah membuat setiap nama variabel lingkungan dari nama rahasia, diubah untuk menyertakan hanya huruf besar, angka, dan garis bawah, dan agar tidak dimulai dengan angka. Untuk huruf dalam nama, Anda dapat mengonfigurasi langkah untuk menggunakan huruf kecil dengan `lowercase` atau tidak mengubah huruf dengan. `none` Nilai default-nya adalah `uppercase`.
`parse-json-secrets`
(Opsional) Secara default, tindakan menetapkan nilai variabel lingkungan ke seluruh string JSON dalam nilai rahasia. Atur `parse-json-secrets` `true` untuk membuat variabel lingkungan untuk setiap pasangan kunci-nilai di JSON.
Perhatikan bahwa jika JSON menggunakan kunci peka huruf besar/kecil seperti “nama” dan “Nama”, tindakan akan memiliki konflik nama duplikat. Dalam hal ini, atur `parse-json-secrets` ke `false` dan parse nilai rahasia JSON secara terpisah.
## Penamaan variabel lingkungan
Variabel lingkungan yang dibuat oleh tindakan diberi nama sama dengan rahasia tempat mereka berasal. Variabel lingkungan memiliki persyaratan penamaan yang lebih ketat daripada rahasia, sehingga tindakan mengubah nama rahasia untuk memenuhi persyaratan tersebut. Misalnya, tindakan mengubah huruf kecil menjadi huruf besar. Jika Anda mengurai JSON rahasia, maka nama variabel lingkungan mencakup nama rahasia dan nama kunci JSON, misalnya. `MYSECRET_KEYNAME` Anda dapat mengonfigurasi tindakan untuk tidak mengubah huruf kecil.
Jika dua variabel lingkungan akan berakhir dengan nama yang sama, tindakan gagal. Dalam hal ini, Anda harus menentukan nama yang ingin Anda gunakan untuk variabel lingkungan sebagai *alias*.
Contoh kapan nama mungkin bertentangan:
+ Sebuah rahasia bernama "MySecret" dan rahasia bernama “mysecret” keduanya akan menjadi variabel lingkungan bernama “MYSECRET”.
+ Sebuah rahasia bernama “SECRET\$1KEYNAME” dan rahasia JSON-parsed bernama “Secret” dengan kunci bernama “keyname” keduanya akan menjadi variabel lingkungan bernama “SECRET\$1KEYNAME”.
Anda dapat mengatur nama variabel lingkungan dengan menentukan *alias, seperti* yang ditunjukkan pada contoh berikut, yang menciptakan variabel bernama. `ENV_VAR_NAME`
```
secret-ids: |
ENV_VAR_NAME, secretId2
```
**Alias kosong**
+ Jika Anda mengatur `parse-json-secrets: true` dan memasukkan alias kosong, diikuti dengan koma dan kemudian ID rahasia, tindakan tersebut memberi nama variabel lingkungan sama dengan kunci JSON yang diurai. Nama variabel tidak termasuk nama rahasia.
Jika rahasia tidak berisi JSON yang valid, maka tindakan akan membuat satu variabel lingkungan dan menamainya sama dengan nama rahasia.
+ Jika Anda mengatur `parse-json-secrets: false` dan memasukkan alias kosong, diikuti dengan koma dan ID rahasia, tindakan tersebut memberi nama variabel lingkungan seolah-olah Anda tidak menentukan alias.
Contoh berikut menunjukkan alias kosong.
```
,secret2
```
## Contoh
**Example 1 Dapatkan rahasia dengan nama dan oleh ARN**
Contoh berikut menciptakan variabel lingkungan untuk rahasia diidentifikasi dengan nama dan oleh ARN.
```
- name: Get secrets by name and by ARN
uses: aws-actions/aws-secretsmanager-get-secrets@v2
with:
secret-ids: |
exampleSecretName
arn:aws:secretsmanager:us-east-2:123456789012:secret:test1-a1b2c3
0/test/secret
/prod/example/secret
SECRET_ALIAS_1,test/secret
SECRET_ALIAS_2,arn:aws:secretsmanager:us-east-2:123456789012:secret:test2-a1b2c3
,secret2
```
Variabel lingkungan dibuat:
```
EXAMPLESECRETNAME: secretValue1
TEST1: secretValue2
_0_TEST_SECRET: secretValue3
_PROD_EXAMPLE_SECRET: secretValue4
SECRET_ALIAS_1: secretValue5
SECRET_ALIAS_2: secretValue6
SECRET2: secretValue7
```
**Example 2 Dapatkan semua rahasia yang dimulai dengan awalan**
Contoh berikut menciptakan variabel lingkungan untuk semua rahasia dengan nama yang dimulai dengan*beta*.
```
- name: Get Secret Names by Prefix
uses: 2
with:
secret-ids: |
beta* # Retrieves all secrets that start with 'beta'
```
Variabel lingkungan dibuat:
```
BETASECRETNAME: secretValue1
BETATEST: secretValue2
BETA_NEWSECRET: secretValue3
```
**Example 3 Parse JSON secara rahasia**
Contoh berikut menciptakan variabel lingkungan dengan mengurai JSON dalam rahasia.
```
- name: Get Secrets by Name and by ARN
uses: aws-actions/aws-secretsmanager-get-secrets@v2
with:
secret-ids: |
test/secret
,secret2
parse-json-secrets: true
```
Rahasianya `test/secret` memiliki nilai rahasia berikut.
```
{
"api_user": "user",
"api_key": "key",
"config": {
"active": "true"
}
}
```
Rahasianya `secret2` memiliki nilai rahasia berikut.
```
{
"myusername": "alejandro_rosalez",
"mypassword": "EXAMPLE_PASSWORD"
}
```
Variabel lingkungan dibuat:
```
TEST_SECRET_API_USER: "user"
TEST_SECRET_API_KEY: "key"
TEST_SECRET_CONFIG_ACTIVE: "true"
MYUSERNAME: "alejandro_rosalez"
MYPASSWORD: "EXAMPLE_PASSWORD"
```
**Example 4 Gunakan huruf kecil untuk nama variabel lingkungan**
Contoh berikut menciptakan variabel lingkungan dengan nama huruf kecil.
```
- name: Get secrets
uses: aws-actions/aws-secretsmanager-get-secrets@v2
with:
secret-ids: exampleSecretName
name-transformation: lowercase
```
Variabel lingkungan dibuat:
```
examplesecretname: secretValue
```
# Gunakan AWS Secrets Manager di GitLab
AWS Secrets Manager terintegrasi dengan GitLab. Anda dapat memanfaatkan rahasia Secrets Manager untuk melindungi GitLab kredensialmu sehingga tidak lagi di-hardcode. GitLab Sebagai gantinya, [GitLab Runner](https://docs.gitlab.com/runner/) mengambil rahasia ini dari Secrets Manager saat aplikasi Anda menjalankan pekerjaan di pipeline GitLab CI/CD.
Untuk menggunakan integrasi ini, Anda akan membuat [penyedia identitas OpenID Connect (OIDC) di IAM dan peran IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_create_oidc.html) AWS Identity and Access Management . Hal ini memungkinkan GitLab Runner untuk mengakses rahasia Secrets Manager Anda. [Untuk informasi lebih lanjut tentang GitLab CI/CD dan OIDC, lihat dokumentasi. GitLab](https://docs.gitlab.com/ci/cloud_services/aws/)
## Pertimbangan-pertimbangan
Jika Anda menggunakan GitLab instans non-publik, Anda tidak dapat menggunakan integrasi Secrets Manager ini. Sebagai gantinya, lihat [GitLab dokumentasi untuk instance non-publik](https://docs.gitlab.com/ci/cloud_services/aws/#configure-a-non-public-gitlab-instance).
## Prasyarat
Untuk mengintegrasikan Secrets Manager dengan GitLab, lengkapi prasyarat berikut:
1.
**Buat AWS Secrets Manager rahasia**
Anda akan memerlukan rahasia Secrets Manager yang akan diambil dalam GitLab pekerjaan Anda dan menghilangkan kebutuhan untuk hard-code kredensil ini. Anda akan memerlukan Secrets Manager Secrets Secrets Secrets Secrets saat [mengonfigurasi GitLab pipeline](#configure-gitlab-pipeline). Untuk informasi selengkapnya, lihat [Buat AWS Secrets Manager rahasia](create_secret.md).
1.
**GitLab Buat penyedia OIDC Anda di konsol IAM.**
Pada langkah ini, Anda akan membuat penyedia OIDC GitLab Anda di konsol IAM. [Untuk informasi selengkapnya, lihat [Membuat penyedia identitas dan dokumentasi OpenID Connect (OIDC)](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_providers_create_oidc.html). GitLab](https://docs.gitlab.com/ci/cloud_services/aws/)
Saat membuat penyedia OIDC di konsol IAM, gunakan konfigurasi berikut:
1. Atur `provider URL` ke GitLab instance Anda. Misalnya, **gitlab.example.com**.
1. Atur `audience` atau `aud` ke**sts.amazonaws.com**.
1.
**Buat peran dan kebijakan IAM**
Anda harus membuat peran dan kebijakan IAM. Peran ini diasumsikan oleh GitLab with [AWS Security Token Service (STS)](https://docs.aws.amazon.com/STS/latest/APIReference/welcome.html). Lihat [Membuat peran menggunakan kebijakan kepercayaan khusus](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-custom.html) untuk informasi selengkapnya.
1. Di konsol IAM, gunakan pengaturan berikut saat membuat peran IAM:
+ Atur `Trusted entity type` ke **Web identity**.
+ Atur `Group` ke **your GitLab group**.
+ Setel `Identity provider` ke URL penyedia yang sama ([GitLab instance](#step2-oidc-provider)) yang Anda gunakan di langkah 2.
+ Setel `Audience` ke [audiens](#step2-oidc-audience) yang sama dengan yang Anda gunakan di langkah 2.
1. Berikut ini adalah contoh kebijakan kepercayaan yang memungkinkan GitLab untuk mengambil peran. Kebijakan kepercayaan Anda harus mencantumkan Akun AWS, GitLab URL, dan [jalur proyek](https://docs.gitlab.com/user/project/) Anda.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "sts:AssumeRoleWithWebIdentity",
"Principal": {
"Federated": "arn:aws:iam::111122223333:oidc-provider/gitlab.example.com"
},
"Condition": {
"StringEquals": {
"gitlab.example.com:aud": [
"sts.amazon.com"
]
},
"StringLike": {
"gitlab.example.com:sub": [
"project_path:mygroup/project-*:ref_type:branch-*:ref:main*"
]
}
}
}
]
}
```
1. Anda juga harus membuat kebijakan IAM untuk mengizinkan GitLab akses ke AWS Secrets Manager. Anda dapat menambahkan kebijakan ini ke kebijakan kepercayaan Anda. Untuk informasi selengkapnya, lihat [Membuat kebijakan IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create-console.html).
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "secretsmanager:GetSecretValue",
"Resource": "arn:aws:secretsmanager:us-east-1:111122223333:secret:your-secret"
}
]
}
```
## Integrasi dengan AWS Secrets Manager GitLab
Setelah menyelesaikan prasyarat, Anda dapat mengonfigurasi untuk menggunakan GitLab Secrets Manager untuk melindungi kredensialnya.
### Konfigurasikan GitLab pipeline untuk menggunakan Secrets Manager
Anda harus memperbarui [file konfigurasi GitLab CI/CD](https://docs.gitlab.com/ci/yaml/yaml_optimization/) Anda dengan informasi berikut:
+ Penonton token diatur ke STS.
+ ID rahasia Secrets Manager.
+ Peran IAM yang ingin Anda asumsikan oleh GitLab Runner saat menjalankan pekerjaan di pipeline. GitLab
+ Di Wilayah AWS mana rahasia disimpan.
GitLab mengambil rahasia dari Secrets Manager dan menyimpan nilai dalam file sementara. Path ke file ini disimpan dalam CI/CD variabel, mirip dengan variabel [tipe file CI/CD](https://docs.gitlab.com/ci/variables/#use-file-type-cicd-variables).
Berikut ini adalah cuplikan file YAMAL untuk file konfigurasi GitLab CI/CD:
```
variables:
AWS_REGION: us-east-1
AWS_ROLE_ARN: 'arn:aws:iam::111122223333:role/gitlab-role'
job:
id_tokens:
AWS_ID_TOKEN:
aud: 'sts.amazonaws.com'
secrets:
DATABASE_PASSWORD:
aws_secrets_manager:
secret_id: "arn:aws:secretsmanager:us-east-1:111122223333:secret:secret-name"
```
Untuk informasi selengkapnya, lihat [dokumentasi integrasi GitLab Secrets Manager](https://docs.gitlab.com/ci/secrets/aws_secrets_manager/).
Secara opsional, Anda dapat menguji konfigurasi OIDC Anda di. GitLab Lihat [GitLab dokumentasi untuk menguji konfigurasi OIDC](https://docs.gitlab.com/ci/cloud_services/aws/#test-the-oidc-configuration) untuk informasi selengkapnya.
## Pemecahan masalah
Berikut ini dapat membantu Anda memecahkan masalah umum yang mungkin Anda temui saat mengintegrasikan Secrets Manager dengan. GitLab
### GitLab Masalah pipa
Jika Anda mengalami masalah GitLab pipeline, pastikan hal berikut:
+ File YAMAL Anda diformat dengan benar. Untuk informasi lebih lanjut, lihat [GitLabdokumentasi](https://docs.gitlab.com/ee/ci/yaml/).
+ GitLab Pipeline Anda mengasumsikan peran yang benar, memiliki izin yang sesuai, dan akses ke rahasia yang benar AWS Secrets Manager .
### Sumber daya tambahan
Sumber daya berikut dapat membantu Anda memecahkan masalah dengan GitLab dan: AWS Secrets Manager
+ [GitLab Pemecahan masalah OIDC](https://docs.gitlab.com/ci/cloud_services/aws/#troubleshooting)
+ [Mendebug Pipa GitLab CI/CD](https://docs.gitlab.com/ee/ci/troubleshooting.html)
+ [Pemecahan masalah](ascp-eks-installation.md#troubleshooting)
# Gunakan AWS Secrets Manager rahasia di AWS IoT Greengrass
AWS IoT Greengrass adalah perangkat lunak yang memperluas kemampuan cloud ke perangkat lokal. Hal ini memungkinkan perangkat untuk mengumpulkan dan menganalisis data lebih dekat ke sumber informasi, bereaksi secara mandiri terhadap acara lokal, dan berkomunikasi secara aman satu sama lain di jaringan lokal.
AWS IoT Greengrass memungkinkan Anda mengautentikasi dengan layanan dan aplikasi dari AWS IoT Greengrass perangkat tanpa kata sandi hard-coding, token, atau rahasia lainnya. Anda dapat menggunakannya AWS Secrets Manager untuk menyimpan dan mengelola rahasia Anda dengan aman di cloud. AWS IoT Greengrass memperluas Secrets Manager ke perangkat AWS IoT Greengrass inti, sehingga konektor dan fungsi Lambda Anda dapat menggunakan rahasia lokal untuk berinteraksi dengan layanan dan aplikasi.
Untuk mengintegrasikan rahasia ke dalam AWS IoT Greengrass grup, Anda membuat sumber daya grup yang mereferensikan rahasia Secrets Manager. Sumber daya rahasia ini mereferensikan rahasia cloud dengan menggunakan ARN terkait. Untuk mempelajari cara membuat, mengelola, dan menggunakan sumber daya rahasia, lihat [Bekerja dengan Sumber Daya Rahasia](https://docs.aws.amazon.com/greengrass/latest/developerguide/secrets-using.html) di Panduan AWS IoT Pengembang.
Untuk menyebarkan rahasia ke AWS IoT Greengrass Core, lihat [Menyebarkan rahasia ke inti. AWS IoT Greengrass](https://docs.aws.amazon.com/greengrass/latest/developerguide/secrets.html)
# Gunakan AWS Secrets Manager rahasia di Parameter Store
AWS Systems Manager Parameter Store menyediakan penyimpanan hierarkis yang aman untuk manajemen data konfigurasi dan manajemen rahasia. Anda dapat menyimpan data seperti kata sandi, string database, dan kode lisensi sebagai nilai parameter. Namun, Parameter Store tidak menyediakan layanan rotasi otomatis untuk rahasia yang disimpan. Sebagai gantinya, Parameter Store memungkinkan Anda untuk menyimpan rahasia Anda di Secrets Manager, dan kemudian mereferensikan rahasia sebagai parameter Parameter Store.
Saat Anda mengonfigurasi Parameter Store dengan Secrets Manager, `secret-id` Parameter Store memerlukan garis miring (/) sebelum nama-string.
Untuk informasi selengkapnya, lihat [Mereferensikan AWS Secrets Manager Rahasia dari Parameter Penyimpanan Parameter](https://docs.aws.amazon.com/systems-manager/latest/userguide/integration-ps-secretsmanager.html) di *Panduan AWS Systems Manager Pengguna*.