翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。
# からシークレットを取得する AWS Secrets Manager
Secrets Manager では、シークレットを取得すると CloudTrail ログエントリを生成します。詳細については、「[で AWS Secrets Manager イベントをログに記録する 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)
+ [Rust](retrieving-secrets-rust.md)
+ [Amazon EKS](integrate_eks.md)
+ [AWS Lambda](retrieving-secrets_lambda.md)
+ [Secrets Manager Agent](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 コンソール](retrieving-secrets-console.md)
+ [AWS Batch](integrating_BATCH.md)
+ [CloudFormation](cfn-example_reference-secret.md)
+ [GitHub ジョブ](retrieving-secrets_github.md)
+ [GitLab](integrating_gitlab.md)
+ [AWS IoT Greengrass](integrating-greengrass.md)
+ [パラメータストア](integrating_parameterstore.md)
# Java を使用して Secrets Manager シークレット値を取得する
アプリケーションでは、任意の AWS SDKs `BatchGetSecretValue`で `GetSecretValue`または を呼び出してシークレットを取得できます。ただし、クライアント側のキャッシュを使用してシークレット値をキャッシュすることをお勧めします。シークレットをキャッシュすると、速度が向上し、コストが削減されます。
シークレットの認証情報を使用してデータベースに接続するには、基本 JDBC ドライバーをラップする Secrets Manager SQL Connection ドライバーを使用します。これはまた、クライアント側のキャッシュを使用するため、Secrets Manager API を呼び出すコストを削減できます。
**Topics**
+ [Java とクライアント側のキャッシュを使用して、Secrets Manager のシークレット値を取得する](retrieving-secrets_cache-java.md)
+ [AWS Secrets Manager シークレットの認証情報を使用して JDBC を使用して SQL データベースに接続する](retrieving-secrets_jdbc.md)
+ [Java AWS SDK を使用して Secrets Manager シークレット値を取得する](retrieving-secrets-java-sdk.md)
# Java とクライアント側のキャッシュを使用して、Secrets Manager のシークレット値を取得する
シークレットを取得するときに、Secrets Manager の Java ベースのキャッシュコンポーネントを使用して、将来使用するためにキャッシュすることができます。キャッシュされたシークレットの取得は、Secrets Manager からの取得よりも高速です。Secrets Manager API を呼び出すにはコストがかかるため、キャッシュを使用するとコストを削減できます。シークレットを取得するすべての方法については、「[シークレットの取得](retrieving-secrets.md)」を参照してください。
キャッシュポリシーは LRU (最近最も使われていない) であるため、キャッシュでシークレットを破棄する必要が生じた場合は、最も最近使われていないシークレットが破棄されます。デフォルトでは、1 時間ごとにキャッシュでシークレットが更新されます。キャッシュで[シークレットが更新される頻度](retrieving-secrets_cache-java-ref_SecretCacheConfiguration.md#retrieving-secrets_cache-java-ref_SecretCacheConfiguration_methods-getCacheItemTTL)を設定できるだけでなく、[シークレットの取得にフック](retrieving-secrets_cache-java-ref_SecretCacheHook.md)させて機能を追加することもできます。
キャッシュ参照が解放されると、キャッシュはガベージコレクションを強制しません。キャッシュの実装には、キャッシュの無効化は含まれていません。キャッシュを実装するのはキャッシュを使用するためであり、セキュリティを強化するためでもセキュリティに焦点を当てるためでもありません。キャッシュ内のアイテムを暗号化するなど、セキュリティを強化する必要がある場合は、所定のインターフェイスと抽象メソッドを使用してください。
このコンポーネントを使用するには、以下が必要です。
+ Java 8 以上の開発環境。Oracle のウェブサイトの「[Java SE Downloads](https://www.oracle.com/technetwork/java/javase/downloads/index.html)」(Java SEのダウンロード) を参照してください。
ソースコードをダウンロードするには、GitHub の「[Secrets Manager Java-based caching client component](https://github.com/aws/aws-secretsmanager-caching-java)」(Secrets Manager の Java ベースのキャッシュクライアントコンポーネント) を参照してください。
コンポーネントをプロジェクトに追加するには、Maven pom.xml ファイルに、次の依存関係を含めます。Maven の詳細については、Apache Maven プロジェクトのウェブサイトの「[Getting Started Guide](https://maven.apache.org/guides/getting-started/index.html)」(入門ガイド) を参照してください。
```
com.amazonaws.secretsmanager
aws-secretsmanager-caching-java
1.0.2
```
**必要な許可:**
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`
詳細については、「[アクセス許可に関するリファレンス](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 シークレットを取得する**
次のコード例は、シークレット文字列を取得する Lambda 関数を示しています。これは関数ハンドラーの外部でのキャッシュのインスタンス化の[ベストプラクティス](https://docs.aws.amazon.com/lambda/latest/dg/best-practices.html)に従うため、Lambda 関数を再度呼び出しても、API は継続して呼び出されません。
```
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
Secrets Manager からリクエストされたシークレットのインメモリキャッシュ。[getSecretString](#retrieving-secrets_cache-java-ref_SecretCache-methods-getSecretString) または [getSecretBinary](#retrieving-secrets_cache-java-ref_SecretCache-methods-getSecretBinary) を使用して、キャッシュからシークレットを取得します。キャッシュの設定は、コンストラクタで [SecretCacheConfiguration](retrieving-secrets_cache-java-ref_SecretCacheConfiguration.md) オブジェクトを渡すことで設定できます。
詳細と例については、「[Java とクライアント側のキャッシュを使用して、Secrets Manager のシークレット値を取得する](retrieving-secrets_cache-java.md)」を参照してください。
## コンストラクタ
`public SecretCache()`
`SecretCache` オブジェクトのデフォルトコンストラクタ。
`public SecretCache(AWSSecretsManagerClientBuilder builder)`
提供された [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) を用いて作成された Secrets Manager クライアントを使用して、新しいキャッシュを構築します。このコンストラクタを使用して、Secrets Manager クライアントをカスタマイズします (特定のリージョンまたはエンドポイントを使用するなど)。
`public SecretCache(AWSSecretsManager client)`
提供された [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) を使用して、新しいシークレットキャッシュを構築します。このコンストラクタを使用して、Secrets Manager クライアントをカスタマイズします (特定のリージョンまたはエンドポイントを使用するなど)。
`public SecretCache(SecretCacheConfiguration config)`
提供された `SecretCacheConfiguration` を使用して、新しいシークレットキャッシュを構築します。
## 方法
### getSecretString
`public String getSecretString(final String secretId)`
Secrets Manager から文字列シークレットを取得します。戻り値は [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)`
Secrets Manager からバイナリシークレットを取得します。戻り値は [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`
キャッシュを強制的に更新します。エラーが発生せずに更新が完了した場合は `true` を返し、そうでない場合は `false` を返します。
### close
`public void close()`
キャッシュを終了します。
# SecretCacheConfiguration
キャッシュされるシークレットの最大キャッシュサイズや有効期限 (TTL) などの、[SecretCache](retrieving-secrets_cache-java-ref_SecretCache.md) のキャッシュ設定オプション。
## コンストラクタ
`public SecretCacheConfiguration`
`SecretCacheConfiguration` オブジェクトのデフォルトコンストラクタ。
## 方法
### getClient
`public AWSSecretsManager getClient()`
キャッシュがシークレットを取得する [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) を返します。
### setClient
`public void setClient(AWSSecretsManager client)`
キャッシュがシークレットを取得する [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) クライアントを設定します。
### getCacheHook
`public SecretCacheHook getCacheHook()`
キャッシュ更新に接続するために使用される [SecretCacheHook](retrieving-secrets_cache-java-ref_SecretCacheHook.md) インターフェイスを返します。
### setCacheHook
`public void setCacheHook(SecretCacheHook cacheHook)`
キャッシュ更新に接続するために使用される [SecretCacheHook](retrieving-secrets_cache-java-ref_SecretCacheHook.md) インターフェイスを設定します。
### getMaxCacheSize
`public int getMaxCacheSize()`
最大キャッシュサイズを返します。デフォルトは 1,024 個のシークレットです。
### setMaxCacheSize
`public void setMaxCacheSize(int maxCacheSize)`
最大キャッシュサイズを設定します。デフォルトは 1,024 個のシークレットです。
### getCacheItemTTL
`public long getCacheItemTTL()`
キャッシュされた項目の TTL をミリ秒単位で返します。キャッシュされたシークレットがこの TTL を超えると、キャッシュは [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) から新しいシークレットのコピーを取得します。デフォルトは 1 時間 (ミリ秒単位) です。
TTL の後にシークレットがリクエストされると、キャッシュはシークレットを同期的に更新します。同期更新が失敗した場合、キャッシュは古いシークレットを返します。
### setCacheItemTTL
`public void setCacheItemTTL(long cacheItemTTL)`
キャッシュされた項目の TTL をミリ秒単位で設定します。キャッシュされたシークレットがこの TTL を超えると、キャッシュは [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) から新しいシークレットのコピーを取得します。デフォルトは 1 時間 (ミリ秒単位) です。
### getVersionStage
`public String getVersionStage()`
キャッシュするシークレットのバージョンを返します。詳細については、「[Secret versions](whats-in-a-secret.md#term_version)」(シークレットバージョン) を参照してください。デフォルトは ` "AWSCURRENT"` です。
### setVersionStage
`public void setVersionStage(String versionStage)`
キャッシュするシークレットのバージョンを設定します。詳細については、「[Secret versions](whats-in-a-secret.md#term_version)」(シークレットバージョン) を参照してください。デフォルトは `"AWSCURRENT"` です。
### SecretCacheConfiguration withClient
`public SecretCacheConfiguration withClient(AWSSecretsManager client)`
シークレットを取得する [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) を設定します。新しい設定を持つ更新された `SecretCacheConfiguration` オブジェクトを返します。
### SecretCacheConfiguration withCacheHook
`public SecretCacheConfiguration withCacheHook(SecretCacheHook cacheHook)`
インメモリキャッシュに接続するために使用されるインターフェイスを設定します。新しい設定を持つ更新された `SecretCacheConfiguration` オブジェクトを返します。
### SecretCacheConfiguration withMaxCacheSize
`public SecretCacheConfiguration withMaxCacheSize(int maxCacheSize)`
最大キャッシュサイズを設定します。新しい設定を持つ更新された `SecretCacheConfiguration` オブジェクトを返します。
### SecretCacheConfiguration withCacheItemTTL
`public SecretCacheConfiguration withCacheItemTTL(long cacheItemTTL)`
キャッシュされた項目の TTL をミリ秒単位で設定します。キャッシュされたシークレットがこの TTL を超えると、キャッシュは [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) から新しいシークレットのコピーを取得します。デフォルトは 1 時間 (ミリ秒単位) です。新しい設定を持つ更新された `SecretCacheConfiguration` オブジェクトを返します。
### SecretCacheConfiguration withVersionStage
`public SecretCacheConfiguration withVersionStage(String versionStage)`
キャッシュするシークレットのバージョンを設定します。詳細については、「[Secret versions](whats-in-a-secret.md#term_version)」(シークレットバージョン) を参照してください。新しい設定を持つ更新された `SecretCacheConfiguration` オブジェクトを返します。
# SecretCacheHook
[SecretCache](retrieving-secrets_cache-java-ref_SecretCache.md) に接続して、キャッシュに保存されているシークレットに対してアクションを実行するインターフェイス。
## put
`Object put(final Object o)`
キャッシュに保存するオブジェクトを準備します。
キャッシュに保存するオブジェクトを返します。
## get
`Object get(final Object cachedObject)`
キャッシュされたオブジェクトからオブジェクトを派生させます。
キャッシュから返すオブジェクトを返します
# AWS Secrets Manager シークレットの認証情報を使用して JDBC を使用して SQL データベースに接続する
Java アプリケーションでは、Secrets Manager SQL 接続ドライバーを使用して、Secrets Manager に保存された認証情報を用いて MySQL、PostgreSQL、Oracle、MSSQLServer、Db2、Redshift のデータベースに接続できます。各ドライバーはベース JDBC ドライバーをラップしているため、JDBC 呼び出しを使用してデータベースにアクセスすることができます。ただし、接続用のユーザーネームとパスワードを渡す代わりに、シークレットの ID を指定します。ドライバーは、Secrets Manager を呼び出してシークレット値を取得してから、シークレット内の認証情報と接続情報を使用してデータベースに接続します。また、ドライバーは [Java のクライアント側のキャッシュライブラリ](retrieving-secrets_cache-java.md)を使用して認証情報をキャッシュするため、その後の接続では Secrets Manager を呼び出す必要はありません。デフォルトでは、1 時間ごと、およびシークレットがローテーションされたときに、キャッシュが更新されます。キャッシュを設定するには、[SecretCacheConfiguration](retrieving-secrets_cache-java-ref_SecretCacheConfiguration.md) を参照してください。
[GitHub](https://github.com/aws/aws-secretsmanager-jdbc ) からソースコードをダウンロードすることができます。
Secrets Manager SQL 接続ドライバーを使用するには、以下が必要です。
+ アプリケーションが Java 8 以降である必要があります。
+ シークレットが次のいずれかである必要があります。
+ [期待される JSON 構造のデータベースシークレット](reference_secret_json_structure.md)。シークレットの形式を確認するには、Secrets Manager コンソールで、シークレットを表示して **[Retrieve secret value]** を選択します。または、 で AWS CLI get[get-secret-value](https://docs.aws.amazon.com/cli/latest/reference/secretsmanager/get-secret-value.html)。
+ Amazon RDS [マネージドシークレット](integrating_how-services-use-secrets_RDS.md)。このタイプのシークレットでは、接続を確立するときにエンドポイントとポートを指定する必要があります。
+ Amazon Redshift [マネージドシークレット](integrating_how-services-use-secrets_RS.md)。このタイプのシークレットでは、接続を確立するときにエンドポイントとポートを指定する必要があります。
データベースが他のリージョンにレプリケートされている場合、別のリージョンのレプリカデータベースに接続するには、接続の作成時にリージョンのエンドポイントとポートを指定します。リージョン接続情報は、追加のキー/値のペア、SSM パラメータストアパラメータ、またはコード構成でシークレットに格納できます。
ドライバーをプロジェクトに追加するには、Maven ビルドファイル `pom.xml` で、次のドライバーの依存関係を追加します。詳細については、Maven Central Repository の web サイトの「[Secrets Manager SQL Connection Library](https://search.maven.org/artifact/com.amazonaws.secretsmanager/aws-secretsmanager-jdbc)」(Secrets Manager SQL 接続ライブラリ) を参照してください。
```
com.amazonaws.secretsmanager
aws-secretsmanager-jdbc
1.0.12
```
このドライバーでは[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)を使用します。Amazon EKS でドライバーを実行すると、サービスアカウントロールの代わりに、実行中のノードの認証情報が取得される可能性があります。これに対処するには、`com.amazonaws:aws-java-sdk-sts` のバージョン 1 を Gradle または Maven プロジェクトファイルに依存関係として追加します。
ファイルで DNS AWS PrivateLink エンドポイント URL とリージョンを設定するには`secretsmanager.properties`:
```
drivers.vpcEndpointUrl = endpoint URL
drivers.vpcEndpointRegion = endpoint region
```
プライマリリージョンをオーバーライドするには、`AWS_SECRET_JDBC_REGION` 環境変数を設定するか、`secretsmanager.properties` ファイルに次の変更を加えます。
```
drivers.region = region
```
**必要な許可:**
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`
詳細については、「[アクセス許可に関するリファレンス](auth-and-access.md#reference_iam-permissions)」を参照してください。
**Topics**
+ [データベースへの接続を確立する](#retrieving-secrets_jdbc_example)
+ [エンドポイントとポートを指定して接続を確立する](#retrieving-secrets_jdbc_example_replica)
+ [c3p0 接続プールを使用して接続を確立する](#retrieving-secrets_jdbc_example_c3po)
+ [c3p0 接続プールを使用して、エンドポイントとポートを指定して接続を確立する](#retrieving-secrets_jdbc_example_c3p0_replica)
## データベースへの接続を確立する
次の例では、シークレット内の認証情報と接続情報を使用してデータベースへの接続を確立する方法を示しています。接続が確立すると、JDBC 呼び出しを使用してデータベースにアクセスすることができます。詳細については、Java ドキュメントのウェブサイトの「[JDBC Basics](https://docs.oracle.com/javase/tutorial/jdbc/basics/index.html)」(JDBC の基本) を参照してください。
------
#### [ 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);
```
------
## エンドポイントとポートを指定して接続を確立する
次の例は、シークレット内の認証情報を使用して、指定したエンドポイントとポートでデータベースへの接続を確立する方法を示しています。
[Amazon RDS マネージドシークレット](integrating_how-services-use-secrets_RDS.md)には、データベースのエンドポイントおよびポートは含まれていません。Amazon RDS が管理するシークレットのマスター認証情報を使用してデータベースに接続するには、コードでマスター認証情報を指定します。
[他のリージョンにレプリケートされるシークレット](replicate-secrets.md)は、リージョンデータベースへの接続のレイテンシーを改善できますが、ソースシークレット以外の接続情報を保持しません。各レプリカは、ソースシークレットのコピーです。リージョン接続情報をシークレットに保存するには、リージョンのエンドポイントとポート情報のキー/値のペアを追加します。
接続が確立すると、JDBC 呼び出しを使用してデータベースにアクセスすることができます。詳細については、Java ドキュメントのウェブサイトの「[JDBC Basics](https://docs.oracle.com/javase/tutorial/jdbc/basics/index.html)」(JDBC の基本) を参照してください。
------
#### [ 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);
```
------
## c3p0 接続プールを使用して接続を確立する
次の例は、ドライバーを使用してシークレットから認証情報および接続情報を取得する `c3p0.properties` ファイルで接続プールを確立する方法を示しています。`user` と `jdbcUrl` には、シークレット ID を入力して接続プールを設定します。その後、プールから接続を取得し、他のデータベース接続として使用することができます。詳細については、Java ドキュメントのウェブサイトの「[JDBC Basics](https://docs.oracle.com/javase/tutorial/jdbc/basics/index.html)」(JDBC の基本) を参照してください。
c3p0 の詳細については、Machinery For Change のウェブサイトの「[c3p0](https://www.mchange.com/projects/c3p0/)」を参照してください。
------
#### [ 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
```
------
## c3p0 接続プールを使用して、エンドポイントとポートを指定して接続を確立する
次の例は、ドライバーを使用して指定されたエンドポイントとポートでシークレットの認証情報を取得する `c3p0.properties` ファイルで接続プールを確立する方法を示しています。その後、プールから接続を取得し、他のデータベース接続として使用することができます。詳細については、Java ドキュメントのウェブサイトの「[JDBC Basics](https://docs.oracle.com/javase/tutorial/jdbc/basics/index.html)」(JDBC の基本) を参照してください。
[Amazon RDS マネージドシークレット](integrating_how-services-use-secrets_RDS.md)には、データベースのエンドポイントおよびポートは含まれていません。Amazon RDS が管理するシークレットのマスター認証情報を使用してデータベースに接続するには、コードでマスター認証情報を指定します。
[他のリージョンにレプリケートされるシークレット](replicate-secrets.md)は、リージョンデータベースへの接続のレイテンシーを改善できますが、ソースシークレット以外の接続情報を保持しません。各レプリカは、ソースシークレットのコピーです。リージョン接続情報をシークレットに保存するには、リージョンのエンドポイントとポート情報のキー/値のペアを追加します。
------
#### [ 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
```
------
# Java AWS SDK を使用して Secrets Manager シークレット値を取得する
アプリケーションでは、任意の AWS SDKs `BatchGetSecretValue`で `GetSecretValue`または を呼び出してシークレットを取得できます。ただし、クライアント側のキャッシュを使用してシークレット値をキャッシュすることをお勧めします。シークレットをキャッシュすると、速度が向上し、コストが削減されます。
+ データベースの認証情報をシークレットに保存する場合は、[Secrets Manager SQL 接続ドライバー](retrieving-secrets_jdbc.md)を使用し、シークレット内の認証情報を用いてデータベースに接続します。
+ 他のタイプのシークレットの場合は、[Secrets Manager の Java ベースのキャッシュコンポーネント](retrieving-secrets_cache-java.md)を使用するか、[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) または [https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/model/BatchGetSecretValueResult.html](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/model/BatchGetSecretValueResult.html) を使用して SDK を直接呼び出します。
次のサンプルコードは、`GetSecretValue` を使用する方法を説明しています。
**必要な許可:**`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);
}
}
}
```
# Python を使用して Secrets Manager のシークレット値を取得する
アプリケーションでは、任意の AWS SDKs `BatchGetSecretValue`で `GetSecretValue`または を呼び出してシークレットを取得できます。ただし、クライアント側のキャッシュを使用してシークレット値をキャッシュすることをお勧めします。シークレットをキャッシュすると、速度が向上し、コストが削減されます。
**Topics**
+ [Python とクライアント側のキャッシュを使用して、Secrets Manager のシークレット値を取得する](retrieving-secrets_cache-python.md)
+ [Python AWS SDK を使用して Secrets Manager シークレット値を取得する](retrieving-secrets-python-sdk.md)
+ [Python AWS SDK を使用して Secrets Manager シークレット値のバッチを取得する](retrieving-secrets-python-batch.md)
# Python とクライアント側のキャッシュを使用して、Secrets Manager のシークレット値を取得する
シークレットを取得するときに、Secrets Manager の Python ベースのキャッシュコンポーネントを使用して、将来使用するためにキャッシュすることができます。キャッシュされたシークレットの取得は、Secrets Manager からの取得よりも高速です。Secrets Manager API を呼び出すにはコストがかかるため、キャッシュを使用するとコストを削減できます。シークレットを取得するすべての方法については、「[シークレットの取得](retrieving-secrets.md)」を参照してください。
キャッシュポリシーは LRU (最近最も使われていない) であるため、キャッシュでシークレットを破棄する必要が生じた場合は、最も最近使われていないシークレットが破棄されます。デフォルトでは、1 時間ごとにキャッシュでシークレットが更新されます。キャッシュで[シークレットが更新される頻度](retrieving-secrets_cache-ref-secretcacheconfig.md)を設定できるだけでなく、[シークレットの取得にフック](retrieving-secrets_cache-ref-secretcachehook.md)させて機能を追加することもできます。
キャッシュ参照が解放されると、キャッシュはガベージコレクションを強制しません。キャッシュの実装には、キャッシュの無効化は含まれていません。キャッシュを実装するのはキャッシュを使用するためであり、セキュリティを強化するためでもセキュリティに焦点を当てるためでもありません。キャッシュ内のアイテムを暗号化するなど、セキュリティを強化する必要がある場合は、所定のインターフェイスと抽象メソッドを使用してください。
このコンポーネントを使用するには、以下が必要です。
+ Python 3.6 以降。
+ botocore 1.12 以降。「[AWS SDK for Python](https://aws.amazon.com/sdk-for-python/)」および「[Botocore](https://botocore.amazonaws.com/v1/documentation/api/latest/index.html)」を参照してください。
+ setuptools\$1scm 3.2 以降。[https://pypi.org/project/setuptools-scm/](https://pypi.org/project/setuptools-scm/) を参照してください。
ソースコードをダウンロードするには、GitHub の「[Secrets Manager Python-based caching client component](https://github.com/aws/aws-secretsmanager-caching-python )」(Secrets Manager の Python ベースのキャッシュクライアントコンポーネント) を参照してください。
コンポーネントをインストールするには、次のコマンドを使用します。
```
$ pip install aws-secretsmanager-caching
```
**必要な許可:**
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`
詳細については、「[アクセス許可に関するリファレンス](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 シークレットを取得する**
次の例は、*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
Secrets Manager から取得されたシークレットのインメモリキャッシュ。[get\$1secret\$1string](#retrieving-secrets_cache-ref-secretcache_get_secret_string) または [get\$1secret\$1binary](#retrieving-secrets_cache-ref-secretcache_get_secret_binary) を使用して、キャッシュからシークレットを取得します。キャッシュの設定は、コンストラクタで [SecretCacheConfig](retrieving-secrets_cache-ref-secretcacheconfig.md) オブジェクトを渡すことで設定できます。
詳細と例については、「[Python とクライアント側のキャッシュを使用して、Secrets Manager のシークレット値を取得する](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
シークレット文字列値を取得します。
リクエストの構文
```
response = cache.get_secret_string(
secret_id='string',
version_stage='string' )
```
パラメータ
+ `secret_id` (*string*): [必須] シークレットの名前または ARN。
+ `version_stage` (*string*): 取得するシークレットのバージョン。詳細については、「[secret versions](whats-in-a-secret.md)」を参照してください。デフォルトは「AWSCURRENT」です。
戻り型
string
## get\$1secret\$1binary
シークレットバイナリ値を取得します。
リクエストの構文
```
response = cache.get_secret_binary(
secret_id='string',
version_stage='string'
)
```
パラメータ
+ `secret_id` (*string*): [必須] シークレットの名前または ARN。
+ `version_stage` (*string*): 取得するシークレットのバージョン。詳細については、「[secret versions](whats-in-a-secret.md)」を参照してください。デフォルトは「AWSCURRENT」です。
戻り型
[base64 でエンコードされた](https://tools.ietf.org/html/rfc4648#section-4)文字列
# SecretCacheConfig
キャッシュされるシークレットの最大キャッシュサイズや有効期限 (TTL) などの、[SecretCache](retrieving-secrets_cache-ref-secretcache.md) のキャッシュ設定オプション。パラメータ
`max_cache_size` (*int*)
最大キャッシュサイズ。デフォルトは `1024` 個のシークレットです。
`exception_retry_delay_base` (*int*)
例外が発生してから、リクエストを再試行するまで待機する秒数。デフォルトは `1` です。
`exception_retry_growth_factor` (*int*)pur
失敗したリクエストの再試行間の待機時間を計算するために使用する増加係数。デフォルトは `2` です。
`exception_retry_delay_max` (*int*)
失敗したリクエスト間の最大待機時間 (秒)。デフォルトは `3600` です。
`default_version_stage` (*str*)
キャッシュするシークレットのバージョン。詳細については、「[Secret versions](whats-in-a-secret.md#term_version)」(シークレットバージョン) を参照してください。デフォルトは `'AWSCURRENT'` です。
`secret_refresh_interval` (*int*)
キャッシュされたシークレット情報の更新間の待機秒数。デフォルトは `3600` です。
`secret_cache_hook` (*SecretCacheHook*)
`SecretCacheHook` 抽象クラスの実装。デフォルト値は `None` です。
# SecretCacheHook
[SecretCache](retrieving-secrets_cache-ref-secretcache.md) に接続して、キャッシュに保存されているシークレットに対してアクションを実行するインターフェイス。
**Topics**
+ [put](#retrieving-secrets_cache-ref-secretcachehook_put)
+ [get](#retrieving-secrets_cache-ref-secretcachehook_get)
## put
キャッシュに保存するオブジェクトを準備します。
リクエストの構文
```
response = hook.put(
obj='secret_object'
)
```
パラメータ
+ `obj` (*object*) -- [必須] シークレットまたはシークレットを含むオブジェクト。
戻り型
オブジェクト
## get
キャッシュされたオブジェクトからオブジェクトを派生させます。
リクエストの構文
```
response = hook.get(
obj='secret_object'
)
```
パラメータ
+ `obj` (*object*): [必須] シークレットまたはシークレットを含むオブジェクト。
戻り型
オブジェクト
# @InjectSecretString
このデコレータは、1 番目と 2 番目の引数として、シークレット ID 文字列と [SecretCache](retrieving-secrets_cache-ref-secretcache.md) を必要とします。このデコレータはシークレット文字列値を返します。シークレットに文字列が含まれている必要があります。
```
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
このデコレータは、1 番目と 2 番目の引数として、シークレット ID 文字列と [SecretCache](retrieving-secrets_cache-ref-secretcache.md) を必要とします。残りの引数は、ラップされた関数のパラメータをシークレット内の JSON キーにマッピングします。シークレットに JSON 構造の文字列が含まれている必要があります。
この JSON を含むシークレットの場合は、次のようになります。
```
{
"username": "saanvi",
"password": "EXAMPLE-PASSWORD"
}
```
次の例では、シークレットから `username` および `password` の JSON 値を抽出する方法を示しています。
```
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')
```
# Python AWS SDK を使用して Secrets Manager シークレット値を取得する
アプリケーションでは、任意の AWS SDKs `BatchGetSecretValue`で `GetSecretValue`または を呼び出してシークレットを取得できます。ただし、クライアント側のキャッシュを使用してシークレット値をキャッシュすることをお勧めします。シークレットをキャッシュすると、速度が向上し、コストが削減されます。
Python アプリケーションの場合は、[Secrets Manager の Python ベースのキャッシュコンポーネント](retrieving-secrets_cache-python.md)を使用するか、[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) または [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/secretsmanager/client/batch_get_secret_value.html](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/secretsmanager/client/batch_get_secret_value.html) を使用して SDK を直接呼び出します。
次のサンプルコードは、`GetSecretValue` を使用する方法を説明しています。
**必要な許可:**`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
```
# Python AWS SDK を使用して Secrets Manager シークレット値のバッチを取得する
次のコード例は、Secrets Manager のシークレットの値をバッチ取得する方法を示しています。
**必要な許可:**
+ `secretsmanager:BatchGetSecretValue`
+ 取得するシークレットごとに `secretsmanager:GetSecretValue` のアクセス許可が必要です。
+ フィルターを使用する場合は、`secretsmanager:ListSecrets` も必要です。
アクセス許可ポリシーの例については、「[例: バッチでシークレット値のグループを取得するためのアクセス許可](auth-and-access_iam-policies.md#auth-and-access_examples_batch)」を参照してください。
**重要**
取得しようとしているグループ内の個別シークレットを取得するためのアクセス許可を拒否する VPCE ポリシーを設定している場合、`BatchGetSecretValue` はシークレット値を返さず、エラーが返されます。
```
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
```
# .NET を使用して Secrets Manager シークレット値を取得する
アプリケーションでは、任意の AWS SDKs `BatchGetSecretValue`で `GetSecretValue`または を呼び出してシークレットを取得できます。ただし、クライアント側のキャッシュを使用してシークレット値をキャッシュすることをお勧めします。シークレットをキャッシュすると、速度が向上し、コストが削減されます。
**Topics**
+ [.NET とクライアント側のキャッシュを使用して、Secrets Manager のシークレット値を取得する](retrieving-secrets_cache-net.md)
+ [を使用して Secrets Manager シークレット値を取得する SDK for .NET](retrieving-secrets-net-sdk.md)
# .NET とクライアント側のキャッシュを使用して、Secrets Manager のシークレット値を取得する
シークレットを取得するときに、Secrets Manager の .NET ベースのキャッシュコンポーネントを使用して、将来使用するためにキャッシュすることができます。キャッシュされたシークレットの取得は、Secrets Manager からの取得よりも高速です。Secrets Manager API を呼び出すにはコストがかかるため、キャッシュを使用するとコストを削減できます。シークレットを取得するすべての方法については、「[シークレットの取得](retrieving-secrets.md)」を参照してください。
キャッシュポリシーは LRU (最近最も使われていない) であるため、キャッシュでシークレットを破棄する必要が生じた場合は、最も最近使われていないシークレットが破棄されます。デフォルトでは、1 時間ごとにキャッシュでシークレットが更新されます。キャッシュで[シークレットが更新される頻度](retrieving-secrets_cache-net-SecretCacheConfiguration.md#retrieving-secrets_cache-net-SecretCacheConfiguration-properties_CacheItemTTL)を設定できるだけでなく、[シークレットの取得にフック](retrieving-secrets_cache-net-ISecretCacheHook.md)させて機能を追加することもできます。
キャッシュ参照が解放されると、キャッシュはガベージコレクションを強制しません。キャッシュの実装には、キャッシュの無効化は含まれていません。キャッシュを実装するのはキャッシュを使用するためであり、セキュリティを強化するためでもセキュリティに焦点を当てるためでもありません。キャッシュ内のアイテムを暗号化するなど、セキュリティを強化する必要がある場合は、所定のインターフェイスと抽象メソッドを使用してください。
このコンポーネントを使用するには、以下が必要です。
+ .NET Framework 4.6.2 以上、または .NET Standard 2.0 以上。Microsoft .NET のウェブサイトの「[.NET のダウンロード](https://dotnet.microsoft.com/en-us/download)」を参照してください。
+ AWS SDK for .NET。「[AWS SDKs](asm_access.md#asm-sdks)」を参照してください。
ソースコードをダウンロードするには、GitHub の「[.NET キャッシュクライアント](https://github.com/aws/aws-secretsmanager-caching-net )」を参照してください。
キャッシュを使用するには、まずキャッシュをインスタンス化してから、`GetSecretString` または `GetSecretBinary` を使用して自分のシークレットを取得する必要があります。連続して取得すると、キャッシュはシークレットのキャッシュされたコピーを返します。
**キャッシュパッケージを入手するには**
+ 次のいずれかを行います。
+ プロジェクトディレクトリで次の .NET CLI コマンドを実行します。
```
dotnet add package AWSSDK.SecretsManager.Caching --version 1.0.6
```
+ `.csproj` ファイルに次のパッケージリファレンスを追加します。
```
```
**必要な許可:**
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`
詳細については、「[アクセス許可に関するリファレンス](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 シークレットを取得する**
次のコード例では、*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 有効期限 (TTL) キャッシュ更新期間を設定する**
次のコード例は、*MySecret* という名前のシークレットを取得し、TTL キャッシュ更新期間を 24 時間に設定する方法を示しています。
```
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
Secrets Manager からリクエストされたシークレットのインメモリキャッシュ。[GetSecretString](#retrieving-secrets_cache-net-SecretsManagerCache-methods-GetSecretString) または [GetSecretBinary](#retrieving-secrets_cache-net-SecretsManagerCache-methods-GetSecretBinary) を使用して、キャッシュからシークレットを取得します。キャッシュの設定は、コンストラクタで [SecretCacheConfiguration](retrieving-secrets_cache-net-SecretCacheConfiguration.md) オブジェクトを渡すことで設定できます。
詳細と例については、「[.NET とクライアント側のキャッシュを使用して、Secrets Manager のシークレット値を取得する](retrieving-secrets_cache-net.md)」を参照してください。
## コンストラクタ
`public SecretsManagerCache()`
`SecretsManagerCache` オブジェクトのデフォルトコンストラクタ。
`public SecretsManagerCache(IAmazonSecretsManager secretsManager)`
提供された [AmazonSecretsManagerClient](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TSecretsManagerClient.html) を用いて作成された Secrets Manager クライアントを使用して、新しいキャッシュを構築します。このコンストラクタを使用して、Secrets Manager クライアントをカスタマイズします (特定のリージョンまたはエンドポイントを使用するなど)。
**パラメータ**
secretsManager
シークレットを取得する [AmazonSecretsManagerClient](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TSecretsManagerClient.html)。
`public SecretsManagerCache(SecretCacheConfiguration config)`
提供された [SecretCacheConfiguration](retrieving-secrets_cache-net-SecretCacheConfiguration.md) を使用して、新しいシークレットキャッシュを構築します。このコンストラクタを使用してキャッシュを設定します (キャッシュするシークレットの数や更新頻度など)。
**パラメータ**
config
キャッシュの設定情報が含まれている [SecretCacheConfiguration](retrieving-secrets_cache-net-SecretCacheConfiguration.md)。
`public SecretsManagerCache(IAmazonSecretsManager secretsManager, SecretCacheConfiguration config)`
提供された [AmazonSecretsManagerClient](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TSecretsManagerClient.html) および [SecretCacheConfiguration](retrieving-secrets_cache-net-SecretCacheConfiguration.md) を使用して作成された Secrets Manager クライアントを使用して、新しいキャッシュを構築します。このコンストラクタを使用して Secrets Manager クライアントをカスタマイズし (特定のリージョンまたはエンドポイントを使用するなど)、キャッシュを構成します (キャッシュするシークレットの数や更新頻度など)。
**パラメータ**
secretsManager
シークレットを取得する [AmazonSecretsManagerClient](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TSecretsManagerClient.html)。
config
キャッシュの設定情報が含まれている [SecretCacheConfiguration](retrieving-secrets_cache-net-SecretCacheConfiguration.md)。
## 方法
### GetSecretString
`public async Task GetSecretString(String secretId)`
Secrets Manager から文字列シークレットを取得します。パラメータ
secretId
取得するシークレットの ARN または名前。
### GetSecretBinary
`public async Task GetSecretBinary(String secretId)`
Secrets Manager からバイナリシークレットを取得します。パラメータ
secretId
取得するシークレットの ARN または名前。
### RefreshNowAsync
`public async Task RefreshNowAsync(String secretId)`
Secrets Manager からのシークレット値をリクエストし、変更があればキャッシュを更新します。既存のキャッシュエントリがない場合は、新しいキャッシュエントリを作成します。更新に成功した場合は、`true` を返します。パラメータ
secretId
取得するシークレットの ARN または名前。
### GetCachedSecret
`public SecretCacheItem GetCachedSecret(string secretId)`
指定されたシークレットのキャッシュエントリがキャッシュに存在する場合、そのキャッシュエントリを返します。それ以外の場合は、Secrets Manager からシークレットを取得し、新しいキャッシュエントリを作成します。パラメータ
secretId
取得するシークレットの ARN または名前。
# SecretCacheConfiguration
キャッシュされるシークレットの最大キャッシュサイズや有効期限 (TTL) などの、[SecretsManagerCache](retrieving-secrets_cache-net-SecretsManagerCache.md) のキャッシュ設定オプション。
## プロパティ
### CacheItemTTL
`public uint CacheItemTTL { get; set; }`
キャッシュ項目の TTL (ミリ秒単位)。デフォルトは `3600000` ミリ秒 (1 時間) です。最大値は `4294967295` ms で、約 49.7 日です。
### MaxCacheSize
`public ushort MaxCacheSize { get; set; }`
最大キャッシュサイズ。デフォルトは 1,024 個のシークレットです。最大値は 65,535 です。
### VersionStage
`public string VersionStage { get; set; }`
キャッシュするシークレットのバージョン。詳細については、「[Secret versions](whats-in-a-secret.md#term_version)」(シークレットバージョン) を参照してください。デフォルトは `"AWSCURRENT"` です。
### クライアント
`public IAmazonSecretsManager Client { get; set; }`
シークレットを取得する [AmazonSecretsManagerClient](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TSecretsManagerClient.html)。`null` の場合、キャッシュは新しいクライアントをインスタンス化します。デフォルトは `null` です。
### CacheHook
`public ISecretCacheHook CacheHook { get; set; }`
[ISecretCacheHook](retrieving-secrets_cache-net-ISecretCacheHook.md)。
# ISecretCacheHook
[SecretsManagerCache](retrieving-secrets_cache-net-SecretsManagerCache.md) に接続して、キャッシュに保存されているシークレットに対してアクションを実行するインターフェイス。
## 方法
### プット
`object Put(object o);`
キャッシュに保存するオブジェクトを準備します。
キャッシュに保存するオブジェクトを返します。
### Get
`object Get(object cachedObject);`
キャッシュされたオブジェクトからオブジェクトを派生させます。
キャッシュから返すオブジェクトを返します
# を使用して Secrets Manager シークレット値を取得する SDK for .NET
アプリケーションでは、任意の AWS SDKs `BatchGetSecretValue`で `GetSecretValue`または を呼び出してシークレットを取得できます。ただし、クライアント側のキャッシュを使用してシークレット値をキャッシュすることをお勧めします。シークレットをキャッシュすると、速度が向上し、コストが削減されます。
.NET アプリケーションの場合は、[Secrets Manager の .NET ベースのキャッシュコンポーネント](retrieving-secrets_cache-net.md)を使用するか、[https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TGetSecretValueRequest.html](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TGetSecretValueRequest.html) または [https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TBatchGetSecretValueRequest.html](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TBatchGetSecretValueRequest.html) を使用して SDK を直接呼び出します。
次のサンプルコードは、`GetSecretValue` を使用する方法を説明しています。
**必要な許可:**`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;
}
}
}
```
# Go を使用して Secrets Manager シークレット値を取得する
アプリケーションでは、任意の AWS SDKs `BatchGetSecretValue`で `GetSecretValue`または を呼び出してシークレットを取得できます。ただし、クライアント側のキャッシュを使用してシークレット値をキャッシュすることをお勧めします。シークレットをキャッシュすると、速度が向上し、コストが削減されます。
**Topics**
+ [Go とクライアント側のキャッシュを使用して、Secrets Manager のシークレット値を取得する](retrieving-secrets_cache-go.md)
+ [Go AWS SDK を使用して Secrets Manager のシークレット値を取得する](retrieving-secrets-go-sdk.md)
# Go とクライアント側のキャッシュを使用して、Secrets Manager のシークレット値を取得する
シークレットを取得するときに、Secrets Manager の GO ベースのキャッシュコンポーネントを使用して、将来の使用のためにキャッシュすることができます。キャッシュされたシークレットの取得は、Secrets Manager からの取得よりも高速です。Secrets Manager API を呼び出すにはコストがかかるため、キャッシュを使用するとコストを削減できます。シークレットを取得するすべての方法については、「[シークレットの取得](retrieving-secrets.md)」を参照してください。
キャッシュポリシーは LRU (最近最も使われていない) であるため、キャッシュでシークレットを破棄する必要が生じた場合は、最も最近使われていないシークレットが破棄されます。デフォルトでは、1 時間ごとにキャッシュでシークレットが更新されます。キャッシュで[シークレットが更新される頻度](retrieving-secrets_cache-go_CacheConfig.md)を設定できるだけでなく、[シークレットの取得にフック](retrieving-secrets_cache-go_CacheHook.md)させて機能を追加することもできます。
キャッシュ参照が解放されると、キャッシュはガベージコレクションを強制しません。キャッシュの実装には、キャッシュの無効化は含まれていません。キャッシュを実装するのはキャッシュを使用するためであり、セキュリティを強化するためでもセキュリティに焦点を当てるためでもありません。キャッシュ内のアイテムを暗号化するなど、セキュリティを強化する必要がある場合は、所定のインターフェイスと抽象メソッドを使用してください。
このコンポーネントを使用するには、以下が必要です。
+ AWS SDK for Go。「[AWS SDKs](asm_access.md#asm-sdks)」を参照してください。
ソースコードをダウンロードするには、GitHub の「[Secrets Manager Go caching client](https://github.com/aws/aws-secretsmanager-caching-go )」(Secrets Manager の Go キャッシュクライアント) を参照してください。
Go の開発環境を設定するには、Go プログラミング言語のウェブサイトの「[Golang Getting Started](https://golang.org/doc/install)」(Go 言語の使用開始) を参照してください。
**必要な許可:**
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`
詳細については、「[アクセス許可に関するリファレンス](auth-and-access.md#reference_iam-permissions)」を参照してください。
**Topics**
+ [type Cache](retrieving-secrets_cache-go_cache.md)
+ [type CacheConfig](retrieving-secrets_cache-go_CacheConfig.md)
+ [type CacheHook](retrieving-secrets_cache-go_CacheHook.md)
**Example シークレットを取得する**
次のコード例は、シークレットを取得する Lambda 関数を示しています。
```
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)
}
```
# type Cache
Secrets Manager からリクエストされたシークレットのインメモリキャッシュ。[GetSecretString](#retrieving-secrets_cache-go_cache_operations_GetCachedSecret) または [GetSecretBinary](#retrieving-secrets_cache-go_cache_operations_GetSecretBinary) を使用して、キャッシュからシークレットを取得します。
次に、キャッシュの設定方法の例を示します。
```
// 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 },
)
```
詳細と例については、「[Go とクライアント側のキャッシュを使用して、Secrets Manager のシークレット値を取得する](retrieving-secrets_cache-go.md)」を参照してください。
## 方法
### 新
`func New(optFns ...func(*Cache)) (*Cache, error)`
New は機能オプションを使用してシークレットキャッシュを構築します。それ以外の場合はデフォルトが使用されます。新しいセッションから Secrets Manager クライアントを初期化します。CacheConfig をデフォルト値に初期化します。LRU キャッシュをデフォルトの最大サイズで初期化します。
### GetSecretString
`func (c *Cache) GetSecretString(secretId string) (string, error)`
GetSecretString は、指定されたシークレット ID のキャッシュからシークレット文字列値を取得します。シークレット文字列を返し、オペレーションが失敗した場合はエラーを返します。
### GetSecretStringWithStage
`func (c *Cache) GetSecretStringWithStage(secretId string, versionStage string) (string, error)`
GetSecretStringWithStage は、指定されたシークレット ID と[バージョンステージ](whats-in-a-secret.md#term_version)のキャッシュからシークレット文字列値を取得します。シークレット文字列を返し、オペレーションが失敗した場合はエラーを返します。
### GetSecretBinary
`func (c *Cache) GetSecretBinary(secretId string) ([]byte, error) {`
GetSecretBinary は、指定されたシークレット ID のキャッシュからシークレットバイナリ値を取得します。シークレットバイナリを返し、オペレーションが失敗した場合はエラーを返します。
### GetSecretBinaryWithStage
`func (c *Cache) GetSecretBinaryWithStage(secretId string, versionStage string) ([]byte, error)`
GetSecretBinaryWithStage は、指定されたシークレット ID と[バージョンステージ](whats-in-a-secret.md#term_version)のキャッシュからシークレットバイナリ値を取得します。シークレットバイナリを返し、オペレーションが失敗した場合はエラーを返します。
# type CacheConfig
キャッシュされるシークレットの最大キャッシュサイズ、デフォルト[バージョンステージ](whats-in-a-secret.md#term_version)、および有効期限 (TTL) などの、[Cache](retrieving-secrets_cache-go_cache.md) のキャッシュ設定オプション。
```
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
}
```
# type CacheHook
[Cache](retrieving-secrets_cache-go_cache.md) に接続して、キャッシュに保存されているシークレットに対してアクションを実行するインターフェイス。
## 方法
### プット
`Put(data interface{}) interface{}`
キャッシュに保存するオブジェクトを準備します。
### Get
`Get(data interface{}) interface{}`
キャッシュされたオブジェクトからオブジェクトを派生させます。
# Go AWS SDK を使用して Secrets Manager のシークレット値を取得する
アプリケーションでは、任意の AWS SDKs `BatchGetSecretValue`で `GetSecretValue`または を呼び出してシークレットを取得できます。ただし、クライアント側のキャッシュを使用してシークレット値をキャッシュすることをお勧めします。シークレットをキャッシュすると、速度が向上し、コストが削減されます。
Go アプリケーションの場合は、[Secrets Manager の Go ベースのキャッシュコンポーネント](retrieving-secrets_cache-go.md)を使用するか、[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) または [https://docs.aws.amazon.com/sdk-for-go/api/service/secretsmanager/#SecretsManager.BatchGetSecretValue](https://docs.aws.amazon.com/sdk-for-go/api/service/secretsmanager/#SecretsManager.BatchGetSecretValue) を使用して SDK を直接呼び出します。
次の例で、Secrets Manager シークレットの値を取得する方法を示します。
**必要な許可:**`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.
}
```
# Rust を使用して Secrets Manager シークレット値を取得する
アプリケーションでは、任意の AWS SDKs `BatchGetSecretValue`で `GetSecretValue`または を呼び出してシークレットを取得できます。ただし、クライアント側のキャッシュを使用してシークレット値をキャッシュすることをお勧めします。シークレットをキャッシュすると、速度が向上し、コストが削減されます。
**Topics**
+ [Rust とクライアント側のキャッシュを使用して、Secrets Manager のシークレット値を取得する](retrieving-secrets_cache-rust.md)
+ [Rust AWS SDK を使用して Secrets Manager のシークレット値を取得する](retrieving-secrets-rust-sdk.md)
# Rust とクライアント側のキャッシュを使用して、Secrets Manager のシークレット値を取得する
シークレットを取得するときに、Secrets Manager の Rust ベースのキャッシュコンポーネントを使用して、将来使用するためにキャッシュすることができます。キャッシュされたシークレットの取得は、Secrets Manager からの取得よりも高速です。Secrets Manager API を呼び出すにはコストがかかるため、キャッシュを使用するとコストを削減できます。シークレットを取得するすべての方法については、「[シークレットの取得](retrieving-secrets.md)」を参照してください。
キャッシュポリシーは先入れ先出し (FIFO) であるため、キャッシュがシークレットを破棄する必要がある場合、最も古いシークレットは破棄されます。デフォルトでは、1 時間ごとにキャッシュでシークレットが更新されます。次のオプションを設定できます。
+ `max_size` – 最近アクセスされていないシークレットを削除する前に保持するキャッシュされたシークレットの最大数。
+ `ttl` – シークレット状態の更新を要求する前にキャッシュされた項目が有効と見なされる期間。
キャッシュの実装には、キャッシュの無効化は含まれていません。キャッシュを実装するのはキャッシュを使用するためであり、セキュリティを強化するためでもセキュリティに焦点を当てるためでもありません。キャッシュ内のアイテムを暗号化するなど、セキュリティを強化する必要がある場合は、提供されている特性を使用してキャッシュを変更します。
コンポーネントを使用するには、`tokio` を備えた Rust 2021 開発環境が必要です。詳細については、Rust プログラミング言語ウェブサイトで「[はじめに](https://www.rust-lang.org/learn/get-started)」を参照してください。
ソースコードをダウンロードするには、GitHub の「[Secrets Manager Rust-based caching client component](https://github.com/aws/aws-secretsmanager-agent/tree/main/aws_secretsmanager_caching)」を参照してください。
キャッシュコンポーネントをインストールするには、次のコマンドを使用します。
```
cargo add aws_secretsmanager_caching
```
**必要な許可:**
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`
詳細については、「[アクセス許可に関するリファレンス](auth-and-access.md#reference_iam-permissions)」を参照してください。
**Example シークレットを取得する**
次の例は、*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 カスタム設定とカスタムクライアントによるキャッシュのインスタンス化**
次の例は、キャッシュを構成し、*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
```
```
# Rust AWS SDK を使用して Secrets Manager のシークレット値を取得する
アプリケーションでは、任意の AWS SDKs `BatchGetSecretValue`で `GetSecretValue`または を呼び出してシークレットを取得できます。ただし、クライアント側のキャッシュを使用してシークレット値をキャッシュすることをお勧めします。シークレットをキャッシュすると、速度が向上し、コストが削減されます。
Rust アプリケーションの場合は、[Secrets Manager の Rust ベースのキャッシュコンポーネント](retrieving-secrets_cache-rust.md)を使用するか、GetSecretValue または BatchGetSecretValue を使用して [SDK を直接](https://docs.rs/releases/search?query=aws-sdk-secretsmanager)呼び出します。
次の例で、Secrets Manager シークレットの値を取得する方法を示します。
**必要な許可:**`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(())
}
```
# Amazon Elastic Kubernetes Service で AWS Secrets Manager シークレットを使用する
AWS Secrets Manager (ASCP) からのシークレットを Amazon EKS Pod にマウントされたファイルとして表示するには、Kubernetes AWS Secrets Store CSI ドライバーの Secrets and Configuration Provider を使用できます。ASCP は、Amazon EC2 ノードグループ.node グループを実行する Amazon Elastic Kubernetes Service 1.17\$1 ではサポートされていません。 AWS Fargate ASCP を使用すると、秘密マネジャー でシークレットを保存および管理し、Amazon EKS で実行されているワークロードからシークレットを取得できます。シークレットに JSON 形式の複数のキー/値ペアが含まれている場合は、Amazon EKS にマウントするキー/値ペアを選択できます。ASCP は JMESPath 構文を使用して、シークレット内のキーと値のペアをクエリします。ASCP はパラメータストアパラメータを使用しても動作します。ASCP には、Amazon EKS による 2 つの認証方法が用意されています。最初のアプローチでは、サービスアカウントの IAM ロール (IRSA) を使用します。2 番目のアプローチでは、Pod Identity を使用します。各アプローチにはそれぞれの利点とユースケースがあります。
## サービスアカウントの IAM ロール (IRSA) を使用した ASCP
ASCP with IAM Roles for Service Accounts (IRSA) を使用すると、Amazon EKS Pod のファイル AWS Secrets Manager として からシークレットをマウントできます。このアプローチは、次の場合に適しています。
+ シークレットをポッドのファイルとしてマウントする必要がある。
+ Amazon EC2 ノードグループで Amazon EKS バージョン 1.17 以降を使用している。
+ JSON 形式のシークレットから特定のキーと値のペアを取得する。
詳細については、「[サービスアカウント (IRSA) の IAM ロールで AWS シークレットと設定プロバイダー CSI を使用する](integrating_ascp_irsa.md)」を参照してください。
## Pod Identity を使用した ASCP
Pod Identity を使用した ASCP の方法では、セキュリティが強化され、Amazon EKS のシークレットにアクセスするための設定が簡素化されます。このアプローチは、次の場合に役立ちます。
+ ポッドレベルでより詳細にアクセス許可を管理する必要がある。
+ Amazon EKS バージョン 1.24 以降を使用している。
+ パフォーマンスとスケーラビリティを向上させる必要がある。
詳細については、「[Amazon EKS の Pod Identity で AWS シークレットと設定プロバイダー CSI を使用する](ascp-pod-identity-integration.md)」を参照してください。
## 適切なアプローチの選択
IRSA を使用した ASCP と Pod Identity を使用した ASCP のどちらを選択するかを決めるときは、次の要素を考慮します。
+ Amazon EKSversion: Pod Identity には Amazon EKS 1.24 以降が必要ですが、CSI ドライバーは Amazon EKS 1.17 以降で動作します。
+ セキュリティ要件: Pod Identity は、ポッドレベルでのより詳細な制御を提供します。
+ パフォーマンス: 通常、大規模な環境では Pod Identity の方がパフォーマンスが向上します。
+ 複雑さ: Pod Identity には個別のサービスアカウントが必要ないため、設定が簡素化されます。
特定の要件と Amazon EKS 環境に最適な方法を選択します。
# Amazon EKS 用の ASCP をインストールする
このセクションでは、Amazon EKS の AWS シークレットと設定プロバイダーをインストールする方法について説明します。ASCP を使用すると、Secrets Manager のシークレットと のパラメータを Amazon EKS Pods のファイル AWS Systems Manager としてマウントできます。
## 前提条件
+ Amazon EKS クラスター
+ Pod Identity 用にバージョン 1.24 以降
+ IRSA 用にバージョン 1.17 以降
+ AWS CLI のインストールと設定
+ kubectl が、Amazon EKS クラスター用にインストールされ、設定されている
+ Helm (バージョン 3.0 以降)
## ASCP をインストールして設定する
ASCP は [secrets-store-csi-provider-aws](https://github.com/aws/secrets-store-csi-driver-provider-aws) リポジトリの GitHub で入手できます。リポジトリには、シークレットを作成してマウントするための YAML ファイルの例も含まれています。
インストール中に、FIPS エンドポイントを使用するように ASCP を設定できます。; エンドポイントのリストについては、「[AWS Secrets Manager エンドポイント](asm_access.md#endpoints)」を参照してください。
**ASCP を EKS アドオンとしてインストールするには**
1. のインストール `eksctl` ([インストール手順](https://docs.aws.amazon.com/eks/latest/eksctl/installation.html))
1. 次のコマンドを実行して、[デフォルト設定](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
```
アドオンを設定する場合は、代わりに次のインストールコマンドを実行します。
```
aws eks create-addon --cluster-name --addon-name aws-secrets-store-csi-driver-provider --configuration-values 'file://path/to/config.yaml'
```
設定ファイルは、YAML ファイルまたは JSON ファイルです。アドオンの設定スキーマを表示するには:
1. 次のコマンドを実行し、最新バージョンのアドオンを書き留めます。
```
aws eks describe-addon-versions --addon-name aws-secrets-store-csi-driver-provider
```
1. 次のコマンドを実行してアドオンの設定スキーマを確認し、 を前のステップのバージョン``に置き換えます。
```
aws eks describe-addon-configuration --addon-name aws-secrets-store-csi-driver-provider --addon-version
```
**Helm を使用して ASCP をインストールするには**
1. リポジトリが最新のチャートを指していることを確認するには、`helm repo update.` を使用します。
1. グラフをインストールします。次に `helm install` コマンドの例を示します。
```
helm install -n kube-system secrets-provider-aws aws-secrets-manager/secrets-store-csi-driver-provider-aws
```
1. FIPS エンドポイントを使用するには、`--set useFipsEndpoint=true` のフラグを追加します。
1. スロットリングを設定するには、`--set-json 'k8sThrottlingParams={"qps": "number of queries per second", "burst": "number of queries per second"}'` のフラグを追加します。
1. Secrets Store CSI ドライバーがクラスターに既にインストールされている場合は、`--set secrets-store-csi-driver.install=false` フラグを追加します。これにより、依存関係としての Secrets Store CSI ドライバーのインストールはスキップされます。
**リポジトリ内の YAML を使用してインストールするには**
+ 次のコマンドを使用します。
```
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
```
## インストールを検証する
EKS クラスター、Secrets Store CSI ドライバー、ASCP プラグインのインストールを検証するには、次の手順に従います。
1. EKS クラスターを検証します。
```
eksctl get cluster --name clusterName
```
このコマンドは、クラスターに関する情報を返します。
1. Secrets Store CSI ドライバーのインストールを検証します。
```
kubectl get pods -n kube-system -l app=secrets-store-csi-driver
```
`csi-secrets-store-secrets-store-csi-driver-xxx` のような名前の実行されているポッドが表示されます。
1. ASCP プラグインのインストールを検証します。
------
#### [ YAML installation ]
```
$ kubectl get pods -n kube-system -l app=csi-secrets-store-provider-aws
```
出力例:
```
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
```
出力例:
```
NAME READY STATUS RESTARTS AGE
secrets-provider-aws-secrets-store-csi-driver-provider-67890 1/1 Running 0 2m
```
------
`Running` 状態のポッドが表示されます。
これらのコマンドを実行した後に、すべてが正しく設定されている場合は、すべてのコンポーネントがエラーなく実行されます。問題が発生した場合は、問題が発生している特定のポッドのログを確認してトラブルシューティングする必要がある場合があります。
## トラブルシューティング
1. ASCP プロバイダーのログを確認するには、以下を実行します。
```
kubectl logs -n kube-system -l app=csi-secrets-store-provider-aws
```
1. `kube-system` 名前空間内のすべてのポッドのステータスを確認します。
```
kubectl -n kube-system get pods
```
```
kubectl -n kube-system logs pod/PODID
```
CSI ドライバーと ASCP に関連するすべてのポッドが「Running」状態である必要があります。
1. CSI ドライバーのバージョンを確認します。
```
kubectl get csidriver secrets-store.csi.k8s.io -o yaml
```
このコマンドは、インストールされている CSI ドライバーに関する情報を返します。
## その他のリソース
Amazon EKS での ASCP の使用に関する詳細については、次のリソースを参照してください。
+ [Amazon EKS で Pod Identity を使用する](https://docs.aws.amazon.com/eks/latest/userguide/pod-identities.html)
+ [GitHub のAWS Secrets Store CSI ドライバー](https://github.com/aws/secrets-store-csi-driver-provider-aws)
# Amazon EKS の Pod Identity で AWS シークレットと設定プロバイダー CSI を使用する
AWS Secrets and Configuration Provider と Pod Identity Agent for Amazon Elastic Kubernetes Service の統合により、Amazon EKS で実行されているアプリケーションのセキュリティが強化され、設定が簡素化され、パフォーマンスが向上します。Pod Identity は、Secrets Manager からシークレットを取得するとき、またはパラメータストアからパラメータを取得するときに、Amazon EKS の IAM AWS Systems Manager 認証を簡素化します。
Amazon EKS Pod Identity によって Amazon EKS インターフェイスを介してアクセス許可を直接設定できるようになるため、Kubernetes アプリケーションの IAM アクセス許可を設定するプロセスが合理化され、ステップ数が減少し、Amazon EKS と IAM サービスを切り替える必要がなくなります。Pod Identity では、信頼ポリシーを更新することなく複数のクラスターで 1 つの IAM ロールを使用でき、より詳細なアクセスコントロールのための[ロールセッションタグ](https://docs.aws.amazon.com/eks/latest/userguide/pod-id-abac.html#pod-id-abac-tags)がサポートされます。このアプローチは、ロール間でアクセス許可ポリシーを再利用できるようにすることでポリシー管理を簡素化するだけでなく、一致するタグに基づいて AWS リソースへのアクセスを有効にすることでセキュリティを強化します。
## 仕組み
1. Pod Identity はポッドに IAM ロールを割り当てます。
1. ASCP はこのロールを使用して認証します AWS のサービス。
1. 承認されると、ASCP はリクエストされたシークレットを取得し、ポッドで使用できるようにします。
詳細については、「*Amazon EKS ユーザーガイド*」の「[EKS Pod Identity の仕組みを理解する](https://docs.aws.amazon.com/eks/latest/userguide/pod-id-how-it-works.html)」を参照してください。
## 前提条件
**重要**
Pod Identity は、クラウド内の Amazon EKS でのみサポートされています。Amazon EC2 インスタンスの [Amazon EKS Anywhere](https://aws.amazon.com/eks/eks-anywhere/)、[Red Hat OpenShift Service on AWS](https://aws.amazon.com/rosa/)、またはセルフマネージド Kubernetes クラスターではサポートされていません。
+ Amazon EKS クラスター (バージョン 1.24 以降)
+ を介した AWS CLI および Amazon EKS クラスターへのアクセス `kubectl`
+ 2 へのアクセス AWS アカウント (クロスアカウントアクセス用)
## Amazon EKS Pod Identity Agent をインストールする
クラスターで Pod Identity を使用するには、Amazon EKS Pod Identity Agent アドオンをインストールする必要があります。
**Pod Identity Agent をインストールするには**
+ Pod Identity Agent アドオンをクラスターにインストールします。
```
eksctl create addon \
--name eks-pod-identity-agent \
--cluster clusterName \
--region region
```
## Pod Identity を使用して ASCP を設定する
1. ポッドがアクセスする必要があるシークレットに `secretsmanager:GetSecretValue` と `secretsmanager:DescribeSecret` のアクセス許可を付与するアクセス許可ポリシーを作成します。ポリシーの例については「[例: 個々のシークレットを読み、記述するアクセス許可](auth-and-access_iam-policies.md#auth-and-access_examples-read-and-describe)」を参照してください。
1. Pod Identity の Amazon EKS サービスプリンシパルが引き受けることができる IAM ロールを作成します。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "pods.eks.amazonaws.com"
},
"Action": [
"sts:AssumeRole",
"sts:TagSession"
]
}
]
}
```
------
IAM ポリシーをロールにアタッチします。
```
aws iam attach-role-policy \
--role-name MY_ROLE \
--policy-arn POLICY_ARN
```
1. Pod Identity の関連付けを作成します。例については、「*Amazon EKS ユーザーガイド*」の「[Pod Identity の関連付けを作成する](https://docs.aws.amazon.com/eks/latest/userguide/pod-id-association.html#pod-id-association-create)」を参照してください。
1. ポッドにマウントするシークレットを指定する `SecretProviderClass` を作成します。
```
kubectl apply -f https://raw.githubusercontent.com/aws/secrets-store-csi-driver-provider-aws/main/examples/ExampleSecretProviderClass-PodIdentity.yaml
```
`SecretProviderClass` における IRSA と Pod Identity の主な違いは、オプションのパラメータ `usePodIdentity` です。これは、認証アプローチを決定するオプションのフィールドです。指定しない場合、デフォルトではサービスアカウントの IAM ロール (IRSA) が使用されます。
+ EKS Pod Identity を使用するには、`"true", "True", "TRUE", "t", "T"` のいずれかの値を使用します。
+ IRSA を明示的に使用するには、`"false", "False", "FALSE", "f", or "F"` のいずれかの値に設定します。
1. `/mnt/secrets-store` の下に、シークレットをマウントするポッドをデプロイします。
```
kubectl apply -f https://raw.githubusercontent.com/aws/secrets-store-csi-driver-provider-aws/main/examples/ExampleDeployment-PodIdentity.yaml
```
1. プライベート Amazon EKS クラスターを使用する場合は、クラスターがある VPC に AWS STS エンドポイントがあることを確認してください。エンドポイントの作成の詳細については、「*AWS Identity and Access Management ユーザーガイド*」の「[インターフェイス VPC エンドポイント](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_interface_vpc_endpoints.html)」を参照してください。
### シークレットのマウントを検証する
シークレットが正しくマウントされていることを検証するには、次のコマンドを実行します。
```
kubectl exec -it $(kubectl get pods | awk '/pod-identity-deployment/{print $1}' | head -1) -- cat /mnt/secrets-store/MySecret
```
**Amazon EKS Pod Identity に Secrets Manager のシークレットへのアクセスを許可するには**
1. ポッドがアクセスする必要があるシークレットに `secretsmanager:GetSecretValue` と `secretsmanager:DescribeSecret` のアクセス許可を付与するアクセス許可ポリシーを作成します。ポリシーの例については「[例: 個々のシークレットを読み、記述するアクセス許可](auth-and-access_iam-policies.md#auth-and-access_examples-read-and-describe)」を参照してください。
1. シークレットをまだ作成していない場合は、Secrets Manager でシークレットを作成します。
## トラブルシューティング
ポッドのデプロイを記述すると、ほとんどのエラーを表示できます。
**コンテナのエラーメッセージを表示するには**
1. 次のコマンドで、ポッド名のリストを取得します。デフォルトの名前空間を使用していない場合は、`-n NAMESPACE` を使用してください。
```
kubectl get pods
```
1. ポッドを記述するには、次のコマンドで、前のステップで見つけたポッドの ポッド ID を使用します (*PODID* の場合)。デフォルトの名前空間を使用していない場合は、`-n NAMESPACE` を使用してください。
```
kubectl describe pod/PODID
```
**ASCP のエラーを表示するには**
+ プロバイダーログで詳細情報を検索するには、次のコマンドの *PODID* に、*csi-secrets-store-provider-aws* ポッドの ID を入力します。
```
kubectl -n kube-system get pods
kubectl -n kube-system logs pod/PODID
```
# サービスアカウント (IRSA) の IAM ロールで AWS シークレットと設定プロバイダー CSI を使用する
**Topics**
+ [前提条件](#prerequisites)
+ [アクセス制御を設定する](#integrating_ascp_irsa_access)
+ [マウントするシークレットを特定する](#integrating_ascp_irsa_mount)
+ [トラブルシューティング](#integrating_ascp_irsa_trouble)
## 前提条件
+ Amazon EKS クラスター (バージョン 1.17 以降)
+ を介した AWS CLI および Amazon EKS クラスターへのアクセス `kubectl`
## アクセス制御を設定する
ASCP は Amazon EKS Pod Identity を取得し、IAM ロールと交換します。その IAM ロールの IAM ポリシーでアクセス許可を設定します。ASCP が IAM ロールを引き受けると、認証されたシークレットへのアクセス許可が付与されます。他のコンテナは、IAM ロールに関連付けられていない限り、シークレットにアクセスできません。
**Amazon EKS ポッドに Secrets Manager のシークレットへのアクセスを許可するには**
1. ポッドがアクセスする必要があるシークレットに `secretsmanager:GetSecretValue` と `secretsmanager:DescribeSecret` のアクセス許可を付与するアクセス許可ポリシーを作成します。ポリシーの例については「[例: 個々のシークレットを読み、記述するアクセス許可](auth-and-access_iam-policies.md#auth-and-access_examples-read-and-describe)」を参照してください。
1. クラスター用に IAM OpenID Connect (OIDC) プロバイダーがない場合は作成します。詳細については、「*Amazon EKS ユーザーガイド*」の「[クラスターに IAM OIDC プロバイダーを作成する](https://docs.aws.amazon.com/eks/latest/userguide/enable-iam-roles-for-service-accounts.html)」を参照してください。
1. [サービスアカウントの IAM ロール](https://docs.aws.amazon.com/eks/latest/userguide/iam-roles-for-service-accounts.html)を作成して、ポリシーをアタッチします。詳細については、「*Amazon EKS ユーザーガイド*」の「[サービスアカウントの IAM ロールを作成する](https://docs.aws.amazon.com/eks/latest/userguide/iam-roles-for-service-accounts.html)」を参照してください。
1. プライベート Amazon EKS クラスターを使用する場合は、クラスターがある VPC に AWS STS エンドポイントがあることを確認してください。エンドポイントの作成の詳細については、「*AWS Identity and Access Management ユーザーガイド*」の「[インターフェイス VPC エンドポイント](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_interface_vpc_endpoints.html)」を参照してください。
## マウントするシークレットを特定する
ASCP が (ファイルシステム上のファイルとして) Amazon EKS 内にマウントするシークレットを判別するには、[SecretProviderClass](ascp-examples.md#ascp-examples-secretproviderclass) YAML ファイルを作成します。`SecretProviderClass` では、マウントするシークレットと、それらのマウントに使用されるファイル名がリストされます。`SecretProviderClass` は、参照する Amazon EKS ポッドと同じ名前空間にある必要があります。
### シークレットをファイルとしてマウントする
次の手順は、サンプル YAML ファイル ([ExampleSecretProviderClass.yaml](https://github.com/aws/secrets-store-csi-driver-provider-aws/blob/main/examples/ExampleSecretProviderClass-IRSA.yaml) と [ExampleDeployment.yaml](https://github.com/aws/secrets-store-csi-driver-provider-aws/blob/main/examples/ExampleDeployment-IRSA.yaml)) を使用してシークレットをファイルとしてマウントする方法を示します。
**Amazon EKS でシークレットをマウントするには**
1. `SecretProviderClass` をポッドに適用します。
```
kubectl apply -f ExampleSecretProviderClass.yaml
```
1. ポッドをデプロイします。
```
kubectl apply -f ExampleDeployment.yaml
```
1. ASCP はファイルをマウントします。
## トラブルシューティング
ポッドのデプロイを記述すると、ほとんどのエラーを表示できます。
**コンテナのエラーメッセージを表示するには**
1. 次のコマンドで、ポッド名のリストを取得します。デフォルトの名前空間を使用していない場合は、`-n nameSpace` を使用してください。
```
kubectl get pods
```
1. ポッドを記述するには、次のコマンドで、前のステップで見つけたポッドの ポッド ID を使用します (*podId* の場合)。デフォルトの名前空間を使用していない場合は、`-n nameSpace` を使用してください。
```
kubectl describe pod/podId
```
**ASCP のエラーを表示するには**
+ プロバイダーログで詳細情報を検索するには、次のコマンドの *podId* に、*csi-secrets-store-provider-aws* ポッドの ID を入力します。
```
kubectl -n kube-system get pods
kubectl -n kube-system logs Pod/podId
```
+
**`SecretProviderClass` CRD がインストールされていることを確認します。**
```
kubectl get crd secretproviderclasses.secrets-store.csi.x-k8s.io
```
このコマンドは、`SecretProviderClass` カスタムリソース定義に関する情報を返します。
+
**SecretProviderClass オブジェクトが作成されたことを確認します。**
```
kubectl get secretproviderclass SecretProviderClassName -o yaml
```
# AWS シークレットと設定プロバイダーのコード例
## ASCP の認証とアクセスコントロールの例
### 例: Amazon EKS Pod Identity サービス (pods.eks.amazonaws.com) がロールを引き受け、セッションにタグを付けることを許可する IAM ポリシー:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "pods.eks.amazonaws.com"
},
"Action": [
"sts:AssumeRole",
"sts:TagSession"
]
}
]
}
```
------
## SecretProviderClass
ASCP を使用して Amazon EKS にマウントするシークレットを YAML で記述します。例については「[SecretProviderClass の使用](#ascp-scenarios-secretproviderclass)」を参照してください。
### SecretProviderClass YAML 構造
```
apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
name: name
spec:
provider: aws
parameters:
region:
failoverRegion:
pathTranslation:
usePodIdentity:
preferredAddressType:
objects:
```
パラメータフィールドには、以下のマウントリクエストの詳細が含まれます。
**リージョン**
(オプション) シークレット AWS リージョン の 。このフィールドを使用しない場合、ASCP はノード上のアノテーションからリージョンを検索します。この検索では、マウントリクエストにオーバーヘッドが追加されるため、大量のポッドを使用するクラスターでリージョンを指定することをお勧めします。
同時に `failoverRegion` も指定すると、ASCP は両方のリージョンからシークレットを試行します。どちらかのリージョンが認証の問題などで 4xx エラーを返した場合、ASCP はいずれのシークレットもマウントしません。シークレットが `region` から正常に取得されると、ASCP はそのシークレット値をマウントします。`region` からはシークレットが正常に取得されないものの、`failoverRegion` からは正常に取得された場合、ASCP は取得された方のシークレット値をマウントします。
**failoverRegion**
(オプション) このフィールドを含めると、ASCP は `region` で定義されているリージョンと、このフィールドで定義されているリージョンからのシークレット取得を試行します。どちらかのリージョンが認証の問題などで 4xx エラーを返した場合、ASCP はいずれのシークレットもマウントしません。シークレットが `region` から正常に取得されると、ASCP はそのシークレット値をマウントします。`region` からはシークレットが正常に取得されないものの、`failoverRegion` からは正常に取得された場合、ASCP は取得された方のシークレット値をマウントします。このフィールドの使用例については、「[マルチリージョンシークレットのフェイルオーバー](#multi-region-failover)」を参照してください。
**pathTranslation**
(オプション) Amazon EKS のファイル名に、Linux のスラッシュ (/) のようなパス区切り文字が含まれている場合に使用する単一の置換文字。ASCP では、パス区切り文字が含まれているファイルを作成し、マウントすることはできません。代わりに、ASCP はパス区切り文字を別の文字に置き換えます。このフィールドを使用しない場合、置換文字にはアンダースコア (\$1) が使用されます。例えば、`My/Path/Secret` は `My_Path_Secret` としてマウントされます。
文字の置換を防ぐには、文字列 `False` を入力してください。
**usePodIdentity**
(オプション) 認証アプローチを決定します。指定しない場合、デフォルトではサービスアカウントの IAM ロール (IRSA) になります。
+ EKS Pod Identity を使用するには、`"true"`、`"True"`、`"TRUE"`、`"t"`、または `"T"` のいずれかの値を使用します。
+ IRSA を明示的に使用するには、`"false"`、`"False"`、`"FALSE"`、`"f"`、または `"F"`"= のいずれかの値に設定します。
**preferredAddressType**
(オプション) Pod Identity Agent のエンドポイント通信の優先 IP アドレスタイプを指定します。このフィールドは EKS Pod Identity 機能を使用する場合にのみ適用され、サービスアカウントの IAM ロールを使用する場合は無視されます。値では大文字と小文字は区別されません。次の値を指定できます。
+ `"ipv4"`、`"IPv4"`、または `"IPV4"` – Pod Identity Agent IPv4 エンドポイントの使用を強制します
+ `"ipv6"`、`"IPv6"`、または `"IPV6"` – Pod Identity Agent IPv6 エンドポイントの使用を強制します
+ 指定なし – 自動エンドポイント選択を使用し、最初に IPv4 エンドポイントを試して、IPv4 が失敗した場合は IPv6 エンドポイントにフォールバックします
**objects**
マウントするシークレットの YAML 宣言を含む文字列 YAML 複数行の文字列またはパイプ (\$1) 文字を使用することをお勧めします。
**objectName**
必須。取得するシークレットまたはパラメータの名前を指定します。Secrets Manager の場合、これは [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) パラメータであり、シークレットのわかりやすい名前または完全な ARN のいずれかを使用できます。SSM Parameter Store の場合、これはパラメータの [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) であり、パラメータの名前または完全な ARN のいずれかを使用できます。
**objectType**
`objectName` で Secrets Manager ARN を使用しない場合は必須。`secretsmanager` または `ssmparameter` のいずれかになります。
**objectAlias**
(オプション) Amazon EKS ポッド内のシークレットのファイル名。このフィールドを指定しなかった場合、`objectName` がファイル名として表示されます。
**filePermission**
(オプション) シークレットをマウントするファイルアクセス許可を指定する 4 桁の 8 進文字列。このフィールドを指定しない場合は、デフォルトで `"0644"` になります。
**objectVersion**
(オプション) シークレットのバージョン ID バージョン ID は、シークレットを変更するたびに更新の必要が生じるため、これは推奨されません。デフォルトでは、最新バージョンが使用されます。`failoverRegion` を含めると、このフィールドはプライマリの `objectVersion` になります。
**objectVersionLabel**
(オプション) バージョンのエイリアス デフォルトでは、最新バージョン AWSCURRENT になります。詳細については、「[シークレットバージョン](whats-in-a-secret.md#term_version)」を参照してください。`failoverRegion` を含めると、このフィールドはプライマリの `objectVersionLabel` になります。
**jmesPath**
(オプション) シークレット内のキーから Amazon EKS にマウントされるファイルへのマッピング このフィールドを使用するには、シークレット値を JSON 形式にする必要があります。このフィールドを使用する場合は、サブフィールド `path` および `objectAlias` を含める必要があります。
**パス**
シークレット値の JSON 内のキー/値のペアからのキー フィールドにハイフンが含まれている場合は、一重引用符でエスケープします。例: `path: '"hyphenated-path"'`
**objectAlias**
Amazon EKS ポッドにマウントされるファイル名。フィールドにハイフンが含まれている場合は、一重引用符でエスケープします。例: `objectAlias: '"hyphenated-alias"'`
**filePermission**
(オプション) シークレットをマウントするファイルアクセス許可を指定する 4 桁の 8 進文字列。このフィールドを指定しない場合、デフォルトで親オブジェクトのファイルアクセス許可になります。
**failoverObject**
(オプション) このフィールドを指定した場合、ASCP はプライマリ `objectName` で指定されたシークレットと、`failoverObject`、`objectName` サブフィールドで指定されたシークレットの両方の取得を試行します。どちらかが認証の問題などで 4xx エラーを返した場合、ASCP はいずれのシークレットもマウントしません。シークレットがプライマリ `objectName` から正常に取得されると、ASCP はそのシークレット値のマウントを行います。シークレットが、プライマリ `objectName` からは正常に取得されなかったものの、フェイルオーバー `objectName` からは正常に取得された場合、ASCP はその (取得された) シークレット値をマウントします。このフィールドを含める場合は、フィールド `objectAlias` も含める必要があります。このフィールドの使用例については、「[別のシークレットにフェイルオーバーする](#failover-secret)」を参照してください。
通常、このフィールドはフェイルオーバーシークレットがレプリカではない場合に使用します。レプリカを指定する際の例については、「[マルチリージョンシークレットのフェイルオーバー](#multi-region-failover)」を参照してください。
**objectName**
フェイルオーバーシークレットの名前または完全な ARN ARN を使用する場合、ARN 内のリージョンはフィールド `failoverRegion` と一致する必要があります。
**objectVersion**
(オプション) シークレットのバージョン ID プライマリ `objectVersion` と一致している必要があります。バージョン ID は、シークレットを変更するたびに更新の必要が生じるため、これは推奨されません。デフォルトでは、最新バージョンが使用されます。
**objectVersionLabel**
(オプション) バージョンのエイリアス デフォルトでは、最新バージョン AWSCURRENT になります。詳細については、「[シークレットバージョン](whats-in-a-secret.md#term_version)」を参照してください。
### Amazon EKS ポッドにシークレットをマウントするための基本的な SecretProviderClass 設定を作成します。
------
#### [ Pod Identity ]
同じ Amazon EKS クラスターのシークレットを使用する SecretProviderClass:
```
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 の使用
これらの例を使用して、さまざまなシナリオの SecretProviderClass 設定を作成します。
#### 例: 名前または ARN でシークレットをマウントする
この例では、3 つの異なるタイプのシークレットをマウントする方法を示します。
+ 完全な ARN によって指定されたシークレット
+ 名前で指定されたシークレット
+ シークレットの特定のバージョン
```
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"
```
#### 例: シークレットからキーと値のペアをマウントする
この例では、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
```
#### 例: ファイルアクセス許可でシークレットをマウントする
この例では、特定のファイルアクセス許可を使用してシークレットをマウントする方法を示します。
```
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"
```
#### 例: フェイルオーバー設定の例
これらの例では、シークレットのフェイルオーバーを設定する方法を示します。
##### マルチリージョンシークレットのフェイルオーバー
この例では、複数のリージョンにレプリケートされたシークレットの自動フェイルオーバーを設定する方法を示します。
```
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"
```
##### 別のシークレットにフェイルオーバーする
この例では、(レプリカではない) 別のシークレットへのフェイルオーバーを設定する方法を示します。
```
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"
```
## その他のリソース
Amazon EKS での ASCP の使用に関する詳細については、次のリソースを参照してください。
+ [Amazon EKS で Pod Identity を使用する](https://docs.aws.amazon.com/eks/latest/userguide/pod-identities.html)
+ [AWS シークレットと設定プロバイダーの使用](https://docs.aws.amazon.com/secretsmanager/latest/userguide/integrating_ascp_csi.html)
+ [GitHub のAWS Secrets Store CSI ドライバー](https://github.com/aws/secrets-store-csi-driver-provider-aws)
# AWS Lambda 関数で AWS Secrets Manager シークレットを使用する
AWS Lambda は、サーバーのプロビジョニングや管理を行わずにコードを実行できるようにするサーバーレスコンピューティングサービスです。の一機能である Parameter Store AWS Systems Managerは、設定データ管理とシークレット管理のための安全な階層型ストレージを提供します。 AWS Parameters and Secrets Lambda Extension を使用して、 SDK を使用せずに Lambda 関数でシーク AWS Secrets Manager レットと Parameter Store パラメータを取得してキャッシュできます。この拡張機能の使用の詳細については、「*Lambda デベロッパーガイド*」の「[Lambda 関数で Secrets Manager シークレットを使用する](https://docs.aws.amazon.com/lambda/latest/dg/with-secrets-manager.html)」を参照してください。
## Lambda で Secrets Manager シークレットを使用する
Lambda デベロッパーガイドには、Lambda 関数で Secrets Manager シークレットを使用するための包括的な手順が記載されています。開始するには、以下の手順を実行します。
1. 「[Lambda 関数で Secrets Manager シークレットを使用する](https://docs.aws.amazon.com/lambda/latest/dg/with-secrets-manager.html)」の段階的チュートリアルに従います。これには、以下が含まれます。
+ 任意のランタイム (Python、Node.js、Java) で Lambda 関数を作成する
+ AWS パラメータとシークレットの Lambda 拡張機能をレイヤーとして追加する
+ 必要なアクセス許可を設定する
+ 拡張機能からシークレットを取得するためのコードを記述する
+ 関数をテストする
1. キャッシュ設定やタイムアウトなど、拡張機能の動作を設定するための環境変数について説明します
1. シークレットローテーションを使用する際のベストプラクティスを理解する
### VPC で Secrets Manager と Lambda を使用する
Lambda 関数が VPC で実行されている場合は、拡張機能が Secrets Manager を呼び出すことができるように VPC エンドポイントを作成する必要があります。詳細については、「[AWS Secrets Manager VPC エンドポイントの使用](vpc-endpoint-overview.md)」を参照してください。
## AWS パラメータとシークレットの Lambda 拡張機能の使用
この拡張機能では、Secrets Manager のシークレットと Parameter Store のパラメータの両方を取得できます。拡張機能で Parameter Store のパラメータを使用する方法の詳細については、「*AWS Systems Manager ユーザーガイド*」の「[Lambda 関数での Parameter Store のパラメータの使用](https://docs.aws.amazon.com/systems-manager/latest/userguide/ps-integration-lambda-extensions.html)」を参照してください。
Systems Manager のドキュメントには以下が含まれます。
+ 拡張機能が Parameter Store と連携する方法の詳細な説明
+ Lambda 関数に拡張機能を追加する方法の説明
+ 拡張機能を設定するための環境変数
+ パラメータを取得するためのサンプルコマンド
+ サポートされているすべてのアーキテクチャとリージョンの拡張機能 ARN の完全なリスト
# AWS Secrets Manager エージェントの使用
## Secrets Manager Agent の仕組み
AWS Secrets Manager エージェントは、コンピューティング環境全体で Secrets Manager からシークレットを使用する方法を標準化するのに役立つクライアント側の HTTP サービスです。これは次のサービスと併用できます。
+ AWS Lambda
+ Amazon Elastic Container Service
+ アマゾン エラスティックKubernetesサービス
+ Amazon Elastic Compute Cloud
Secrets Manager Agent はシークレットを取得してメモリにキャッシュするため、アプリケーションは Secrets Manager を直接呼び出す代わりに localhost からシークレットを取得できます。Secrets Manager Agent はシークレットのみを読み取ることができます。シークレットを変更することはできません。
**重要**
Secrets Manager エージェントは、環境の AWS 認証情報を使用して Secrets Manager を呼び出します。これには、シークレットセキュリティの向上に役立つ Server Side Request Forgery (SSRF) に対する保護が含まれています。Secrets Manager Agent は、デフォルトで最高優先度のキー交換としてポスト量子 ML-KEM キー交換を使用します。
## Secrets Manager Agent のキャッシュについて
Secrets Manager Agent はインメモリキャッシュを使用するため、Secrets Manager Agent を再起動するとキャッシュがリセットされます。以下に基づいて、キャッシュされたシークレット値を定期的に更新します。
+ デフォルトの更新頻度 (TTL) は 300 秒です
+ 設定ファイルを使用して TTL を変更できます。
+ 更新は、TTL の有効期限が切れた後にシークレットをリクエストしたときに発生します。
**注記**
Secrets Manager Agent にはキャッシュ無効化は含まれません。キャッシュエントリの有効期限が切れる前にシークレットがローテーションすると、Secrets Manager Agent は古いシークレット値を返すことがあります。
Secrets Manager Agent は、`GetSecretValue` のレスポンスと同じ形式でシークレット値を返します。シークレット値はキャッシュ内で暗号化されません。
**Topics**
+ [Secrets Manager Agent の仕組み](#agent-overview)
+ [Secrets Manager Agent のキャッシュについて](#agent-caching)
+ [Secrets Manager Agentをビルドする](#secrets-manager-agent-build)
+ [Secrets Manager Agent をインストールする](#secrets-manager-agent-install)
+ [Secrets Manager Agent を使用してシークレットを取得する](#secrets-manager-agent-call)
+ [`refreshNow` パラメータについて](#secrets-manager-agent-refresh)
+ [Secrets Manager Agent の構成](#secrets-manager-agent-config)
+ [オプション機能](#secrets-manager-agent-features)
+ [ログ記録](#secrets-manager-agent-log)
+ [セキュリティに関する考慮事項](#secrets-manager-agent-security)
## Secrets Manager Agentをビルドする
開始する前に、プラットフォーム用の標準開発ツールと Rust ツールがインストールされていることを確認してください。
**注記**
macOS で `fips` 機能を有効にしてエージェントを構築するには、現在次の回避策が必要です。
`xcrun --show-sdk-path` の実行の結果に設定された `SDKROOT` という環境変数を作成する
------
#### [ RPM-based systems ]
**RPM ベースのシステム上に構築するには**
1. リポジトリで提供されている `install` スクリプトを使用します。
スクリプトは、起動時にランダムな SSRF トークンを生成し、ファイル `/var/run/awssmatoken` に保存します。トークンは、インストールスクリプトが作成する `awssmatokenreader` グループによって読み取り可能です。
1. アプリケーションがトークンファイルを読み取れるようにするには、アプリケーションが実行するユーザーアカウントを `awssmatokenreader` グループに追加する必要があります。例えば、次の usermod コマンドを使用してトークンファイルを読み取るアクセス許可をアプリケーションに付与できます。ここで ** は、アプリケーションを実行するユーザー ID です。
```
sudo usermod -aG awssmatokenreader
```
**開発ツールのインストール**
AL2023 などの RPM ベースのシステムでは、開発ツールグループをインストールします。
```
sudo yum -y groupinstall "Development Tools"
```
1.
**Rust のインストール**
「*Rust ドキュメント*」の「[Rust のインストール](https://www.rust-lang.org/tools/install)」の指示に従います。
```
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh # Follow the on-screen instructions
. "$HOME/.cargo/env"
```
1.
**エージェントの構築**
cargo build コマンドを使用して Secrets Manager Agent をビルドします。
```
cargo build --release
```
実行ファイルは `target/release/aws_secretsmanager_agent` にあります。
------
#### [ Debian-based systems ]
**Debian ベースのシステム上に構築するには**
1.
**開発ツールのインストール**
Ubuntu などの Debian ベースのシステムでは、build-essential パッケージをインストールします。
```
sudo apt install build-essential
```
1.
**Rust のインストール**
「*Rust ドキュメント*」の「[Rust のインストール](https://www.rust-lang.org/tools/install)」の指示に従います。
```
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh # Follow the on-screen instructions
. "$HOME/.cargo/env"
```
1.
**エージェントの構築**
cargo build コマンドを使用して Secrets Manager Agent をビルドします。
```
cargo build --release
```
実行ファイルは `target/release/aws_secretsmanager_agent` にあります。
------
#### [ Windows ]
**Windows でビルドするには**
1.
**開発環境のセットアップ**
「*Microsoft Windows ドキュメント*」の「[Windows for Rust で開発環境をセットアップする](https://learn.microsoft.com/en-us/windows/dev-environment/rust/setup)」の手順に従います。
1.
**エージェントの構築**
cargo build コマンドを使用して Secrets Manager Agent をビルドします。
```
cargo build --release
```
実行ファイルは `target/release/aws_secretsmanager_agent.exe` にあります。
------
#### [ Cross-compile natively ]
**ネイティブにクロスコンパイルするには**
1.
**クロスコンパイルツールをインストールする**
Ubuntu など、mingw-w64 パッケージが利用可能なディストリビューションでは、クロスコンパイルツールチェーンをインストールします。
```
# Install the cross compile tool chain
sudo add-apt-repository universe
sudo apt install -y mingw-w64
```
1.
**Rust ビルドターゲットを追加する**
Windows GNU ビルドターゲットをインストールします:
```
rustup target add x86_64-pc-windows-gnu
```
1.
**Windows 用にビルドする**
Windows 用のエージェントをクロスコンパイルします:
```
cargo build --release --target x86_64-pc-windows-gnu
```
実行ファイルは `target/x86_64-pc-windows-gnu/release/aws_secretsmanager_agent.exe` にあります。
------
#### [ Cross compile with Rust cross ]
**Rust cross を使用してクロスコンパイルするには**
クロスコンパイルツールがシステムでネイティブに利用できない場合、Rust のクロスプロジェクトを使用できます。詳細については、[https://github.com/cross-rs/cross](https://github.com/cross-rs/cross) を参照してください。
**重要**
ビルド環境には 32GB のディスク容量をお勧めします。
1.
**Docker をセットアップ**
Docker をインストールして構成します:
```
# Install and start docker
sudo yum -y install docker
sudo systemctl start docker
sudo systemctl enable docker # Make docker start after reboot
```
1.
**Docker アクセス許可を設定する**
ユーザーを Docker グループに追加します:
```
# Give ourselves permission to run the docker images without sudo
sudo usermod -aG docker $USER
newgrp docker
```
1.
**Windows 用にビルドする**
クロスをインストールし、実行可能ファイルを構築します:
```
# Install cross and cross compile the executable
cargo install cross
cross build --release --target x86_64-pc-windows-gnu
```
------
## Secrets Manager Agent をインストールする
次のインストールオプションからコンピューティング環境を選択します。
------
#### [ Amazon EC2 ]
**Amazon EC2 で Secrets Manager Agent をインストールするには**
1.
**設定ディレクトリに移動する**
設定ディレクトリに変更します:
```
cd aws_secretsmanager_agent/configuration
```
1.
**インストールスクリプトを実行する**
リポジトリで提供されている `install` スクリプトを実行します。
スクリプトは、起動時にランダムな SSRF トークンを生成し、ファイル `/var/run/awssmatoken` に保存します。トークンは、インストールスクリプトが作成する `awssmatokenreader` グループによって読み取り可能です。
1.
**アプリケーションのアクセス許可を設定する**
アプリケーションが実行されるユーザーアカウントを `awssmatokenreader` グループに追加します:
```
sudo usermod -aG awssmatokenreader APP_USER
```
*APP\$1USER* を、アプリケーションが実行されるユーザー ID に置き換えます。
------
#### [ Container Sidecar ]
Docker を使用して、Secrets Manager Agent をアプリケーションと一緒にサイドカーコンテナとして実行できます。その後、アプリケーションは Secrets Manager Agent が提供するローカル HTTP サーバーからシークレットを取得できます。Docker の詳細については、「[Docker ドキュメント](https://docs.docker.com)」を参照してください。
**Secrets Manager Agent のサイドカーコンテナを作成するには**
1.
**エージェント Dockerfile を作成する**
Secrets Manager Agent サイドカーコンテナ用の Dockerfile を作成します:
```
# 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.
**アプリケーション Dockerfile を作成する**
クライアントアプリケーション用の Dockerfile を作成します。
1.
**Docker Compose ファイルを作成する**
Docker Compose ファイルを作成して、共有ネットワークインターフェイスで両方のコンテナを実行します:
**重要**
Secrets Manager エージェントを使用するには、アプリケーションの AWS 認証情報と SSRF トークンをロードする必要があります。Amazon EKS と Amazon ECS については、以下を参照してください。
「*Amazon EKS ユーザーガイド*」の「[アクセスの管理](https://docs.aws.amazon.com/eks/latest/userguide/cluster-auth.html)」
「*Amazon ECS デベロッパーガイド*」の「[Amazon ECS タスク IAM ロール](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html)」
```
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.
**エージェントバイナリのコピー**
`secrets-manager-agent` バイナリを Dockerfiles および Docker Compose ファイルと同じディレクトリにコピーします。
1.
**コンテナの構築と実行**
Docker Compose を使用し、コンテナを構築して実行します:
```
docker-compose up --build
```
1.
**次の手順**
クライアントコンテナから、Secrets Manager Agent を使用してシークレットを取得できるようになりました。詳細については、「[Secrets Manager Agent を使用してシークレットを取得する](#secrets-manager-agent-call)」を参照してください。
------
#### [ Lambda ]
[Secrets Manager Agent を Lambda 拡張機能としてパッケージ化できます](https://docs.aws.amazon.com/lambda/latest/dg/packaging-layers.html)。次に、[Lambda 関数にレイヤーとして追加](https://docs.aws.amazon.com/lambda/latest/dg/adding-layers.html)し、Lambda 関数から Secrets Manager Agent を呼び出してシークレットを取得します。
次の手順は、[https://github.com/aws/aws-secretsmanager-agent](https://github.com/aws/aws-secretsmanager-agent) のサンプルスクリプト `secrets-manager-agent-extension.sh` を使用して *MyTest* という名前のシークレットを取得し、Secrets Manager Agent を Lambda 拡張機能としてインストールする方法を示します。
**Secrets Manager Agent 用の Lambda 拡張機能を作成するには**
1.
**エージェントレイヤーをパッケージ化する**
Secrets Manager Agent コードパッケージのルートから、次のコマンドを実行します:
```
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.
**SSRF トークンを設定する**
エージェントのデフォルト設定では、SSRF トークンは、事前に設定された `AWS_SESSION_TOKEN` または `AWS_CONTAINER_AUTHORIZATION_TOKEN` 環境変数 (SnapStart が有効になっている Lambda 関数の後半変数) で設定された値に自動的に設定されます。または、Lambda 関数の任意の値を使用して `AWS_TOKEN` 環境変数を定義することもできます。これは、この変数が他の 2 つよりも優先されるためです。`AWS_TOKEN` 環境変数を使用する場合は、その環境変数を `lambda:UpdateFunctionConfiguration` 呼び出しで設定する必要があります。
1.
**レイヤーを関数にアタッチする**
レイヤーバージョンを Lambda 関数にアタッチします:
```
# Attach the layer version to the Lambda function
aws lambda update-function-configuration \
--function-name $LAMBDA_ARN \
--layers "$LAYER_VERSION_ARN"
```
1.
**関数コードの更新**
`X-Aws-codes-Secrets-Token` ヘッダー値を上記の環境変数から取得した SSRF トークンの値に設定して `http://localhost:2773/secretsmanager/get?secretId=MyTest` のクエリを実行するように Lambda 関数を更新し、シークレットを取得します。Lambda 拡張機能の初期化と登録の遅延に対応するため、アプリケーションコードに再試行ロジックを実装してください。
1.
**関数をテストする**
Lambda 関数を呼び出して、シークレットが正しく取得されていることを確認します。
------
## Secrets Manager Agent を使用してシークレットを取得する
シークレットを取得するには、シークレットの名前または ARN をクエリパラメータとして含めて、ローカルの Secrets Manager Agent エンドポイントを呼び出します。デフォルトでは、Secrets Manager Agent はシークレットの `AWSCURRENT` バージョンを取得します。別のバージョンを取得するには、versionStage または versionId パラメータを使用します。
**重要**
Secrets Manager Agent を保護するためには、各リクエスト `X-Aws-Parameters-Secrets-Token` の一部として SSRF トークンヘッダーを含める必要があります。Secrets Manager Agent は、このヘッダーを持たないリクエストや無効な SSRF トークンを持つリクエストを拒否します。[Secrets Manager Agent の構成](#secrets-manager-agent-config) で SSRF ヘッダー名をカスタマイズできます。
### 必要なアクセス許可
Secrets Manager エージェントは、[AWS 認証情報プロバイダーチェーン](https://docs.aws.amazon.com/sdk-for-rust/latest/dg/credentials.html)を使用する AWS SDK for Rust を使用します。これらの IAM 認証情報の ID は、Secrets Manager Agent がシークレットを取得するためのアクセス許可を決定します。
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`
権限の詳細については、「[のアクセス許可リファレンス AWS Secrets Manager](auth-and-access.md#reference_iam-permissions)」を参照してください。
**重要**
シークレット値が Secrets Manager Agent に取り込まれると、コンピューティング環境と SSRF トークンにアクセスできるすべてのユーザーが Secrets Manager Agent キャッシュからシークレットにアクセスできます。詳細については、「[セキュリティに関する考慮事項](#secrets-manager-agent-security)」を参照してください。
### リクエストの例
------
#### [ curl ]
**Example 例 – curl を使用してシークレットを取得する**
次の curl の例は Secrets Manager Agent からシークレットを取得する方法を示しています。この例では、SSRF がインストールスクリプトによって保存されるファイルに存在するかどうかに依存します。
```
curl -v -H \\
"X-Aws-Parameters-Secrets-Token: $(/var/run/awssmatoken)" \\
'http://localhost:2773/secretsmanager/get?secretId=YOUR_SECRET_ID' \\
echo
```
------
#### [ Python ]
**Example 例 – Python を使用してシークレットを取得する**
次の Python の例は Secrets Manager Agent からシークレットを取得する方法を示しています。この例では、SSRF がインストールスクリプトによって保存されるファイルに存在するかどうかに依存します。
```
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}")
```
------
## `refreshNow` パラメータについて
Secrets Manager Agent は、インメモリキャッシュを使用してシークレット値を保存し、定期的に更新します。デフォルトでは、この更新は、有効期限 (TTL) が切れた後、通常 300 秒ごとにシークレットをリクエストしたときに発生します。ただし、このアプローチでは、特にキャッシュエントリの有効期限が切れる前にシークレットがローテーションした場合、シークレット値が古くなることがあります。
この制限に対応するため、Secrets Manager Agent は URL で `refreshNow` というパラメータをサポートしています。このパラメータを使用して、シークレットの値の即時更新を強制し、キャッシュをバイパスして最新の情報を取得できます。
**デフォルトの動作 (`refreshNow` なし)**
+ TTL の有効期限が切れるまでキャッシュされた値を使用します
+ TTL の後にのみシークレットを更新します (デフォルトは 300 秒)
+ キャッシュの有効期限が切れる前にシークレットがローテーションすると、古い値を返す可能性があります
**`refreshNow=true` での動作**
+ キャッシュを完全にバイパスします
+ Secrets Manager から直接、最新のシークレット値を取得します
+ キャッシュを新しい値で更新し、TTL をリセットします
+ 常に最新のシークレット値を取得するようにします
### シークレット値を強制更新する
**重要**
`refreshNow` の初期値は `false` です。`true` に設定すると、Secrets Manager Agent 設定ファイルで指定された TTL が上書きされ、Secrets Manager への API コールが行われます。
------
#### [ curl ]
**Example 例 – curl を使用してシークレットを強制更新する**
次の curl の例は Secrets Manager Agent からシークレットを取得する方法を示しています。この例では、SSRF がインストールスクリプトによって保存されるファイルに存在するかどうかに依存します。
```
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 例 – Python を使用してシークレットを強制更新する**
次の Python の例は Secrets Manager Agent からシークレットを取得する方法を示しています。この例では、SSRF がインストールスクリプトによって保存されるファイルに存在するかどうかに依存します。
```
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}")
```
------
## Secrets Manager Agent の構成
Secrets Manager Agent の設定を変更するには、[TOML](https://toml.io/en/) 設定ファイルを作成し、次に `./aws_secretsmanager_agent --config config.toml` を呼び出します。設定オプション
**`log_level`**
Secrets Manager Agent のログで報告される詳細レベル: DEBUG、INFO、WARN、ERROR、または NONE。デフォルトは INFO です。
**`log_to_file`**
ファイルまたは stdout/stderr にログを記録するかどうか: `true` または `false`。デフォルトは `true` です。
**`http_port`**
ローカル HTTP サーバーのポート範囲は 1024 ～ 65535 です。デフォルトは 2773 です。
**`region`**
リクエストに使用する AWS リージョン。リージョンが指定されていない場合、Secrets Manager Agent は SDK からリージョンを決定します。詳細については、「*AWS SDK for Rust Developer Guide*」の「[Specify your credentials and default Region](https://docs.aws.amazon.com/sdk-for-rust/latest/dg/credentials.html)」を参照してください。
**`ttl_seconds`**
キャッシュされた項目の TTL (秒単位) の範囲は 0 ～ 3600 です。デフォルトは 300 です。0 はキャッシュがないことを示します。
**`cache_size`**
キャッシュに保存できるシークレットの最大数。範囲は 1～1000 です。デフォルトは 1000 です。
**`ssrf_headers`**
Secrets Manager Agent が SSRF トークンを確認するヘッダー名のリスト。デフォルトは「X-Aws-Parameters-Secrets-Token, X-Vault-Token」です。
**`ssrf_env_variables`**
Secrets Manager Agent が SSRF トークンを順番にチェックする環境変数名のリスト。環境変数には、`AWS_TOKEN=file:///var/run/awssmatoken` のようにトークンまたはトークンファイルへの参照を含めることができます。デフォルトは、AWS\$1TOKEN、AWS\$1SESSION\$1TOKEN、AWS\$1CONTAINER\$1AUTHORIZATION\$1TOKEN です。
**`path_prefix`**
リクエストがパスベースのリクエストかどうかを判断するために使用される URI プレフィックス。デフォルトは「/v1/」です。
**`max_conn`**
Secrets Manager Agent が許可する HTTP クライアントからの接続の最大数で、範囲は 1～1000 です。デフォルトは 800 です。
## オプション機能
Secrets Manager Agent は、`--features` フラグを `cargo build` に渡すことで、オプション機能で構築できます。利用できる機能は次のとおりです。構築機能
**`prefer-post-quantum`**
`X25519MLKEM768` を最も優先度の高いキー交換アルゴリズムにします。それ以外にした場合も利用可能ですが、最高の優先度にはなりません。`X25519MLKEM768` は、ハイブリッドのポスト量子セキュアキー交換アルゴリズムです。
**`fips`**
エージェントで使用される暗号スイートを FIPS 承認の暗号のみに制限します。
## ログ記録
**ローカルなログ記録**
Secrets Manager Agent は `log_to_file` 設定変数に応じて、エラーを `logs/secrets_manager_agent.log` ファイルまたは stdout/stderr にローカルでログに記録します。アプリケーションが Secrets Manager Agent を呼び出してシークレットを取得すると、それらの呼び出しはローカルログに表示されます。CloudTrail ログには表示されません。
**ログローテーション**
Secrets Manager Agent は、ファイルが 10 MB に達すると新しいログファイルを作成し、合計で最大 5 つのログファイルを保存します。
**AWS サービスログ記録**
ログは Secrets Manager、CloudTrail、または CloudWatch には送信されません。Secrets Manager Agent からシークレットを取得するリクエストは、これらのログに表示されません。Secrets Manager Agent が Secrets Manager を呼び出してシークレットを取得すると、その呼び出しは `aws-secrets-manager-agent` を含むユーザーエージェント文字列とともに CloudTrail に記録されます。
[Secrets Manager Agent の構成](#secrets-manager-agent-config) でログ記録オプションを設定できます。
## セキュリティに関する考慮事項
**信頼ドメイン**
エージェントアーキテクチャの場合、信頼ドメインは、エージェントエンドポイントと SSRF トークンにアクセスできる場所であり、通常はホスト全体です。同じセキュリティ体制を維持するために、Secrets Manager Agent の信頼ドメインは、Secrets Manager 認証情報が利用可能なドメインと一致する必要があります。例えば、Amazon EC2 では、Secrets Manager Agent の信頼ドメインは、Amazon EC2 のロールを使用する場合の認証情報のドメインと同じになります。
**重要**
Secrets Manager 認証情報がアプリケーションにロックされたエージェントソリューションをまだ使用していないセキュリティ意識の高いアプリケーションでは、言語固有の AWS SDKs またはキャッシュソリューションの使用を検討する必要があります。シークレットの詳細については、「[シークレットの取得](https://docs.aws.amazon.com/secretsmanager/latest/userguide/retrieving-secrets.html)」を参照してください。
# C\$1\$1 AWS SDK を使用して Secrets Manager シークレット値を取得する
C\$1\$1 アプリケーションの場合は、[GetSecretValue](https://docs.aws.amazon.com/goto/SdkForCpp/secretsmanager-2017-10-17/GetSecretValue) または [BatchGetSecretValue](https://docs.aws.amazon.com/goto/SdkForCpp/secretsmanager-2017-10-17/BatchGetSecretValue) を使用して SDK を直接呼び出します。
次の例で、Secrets Manager シークレットの値を取得する方法を示します。
**必要な許可:**`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();
}
```
# JavaScript AWS SDK を使用して Secrets Manager シークレット値を取得する
JavaScript アプリケーションの場合は、[https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/SecretsManager.html#getSecretValue-property](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/SecretsManager.html#getSecretValue-property) または [https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/SecretsManager.html#batchGetSecretValue-property](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/SecretsManager.html#batchGetSecretValue-property) を使用して SDK を直接呼び出します。
次の例で、Secrets Manager シークレットの値を取得する方法を示します。
**必要な許可:**`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;
}
};
```
# Kotlin AWS SDK を使用して Secrets Manager のシークレット値を取得する
Kotlin アプリケーションの場合は、[GetSecretValue](https://github.com/awslabs/aws-sdk-kotlin#generating-api-documentation) または [BatchGetSecretValue](https://github.com/awslabs/aws-sdk-kotlin#generating-api-documentation) を使用して SDK を直接呼び出します。
次の例で、Secrets Manager シークレットの値を取得する方法を示します。
**必要な許可:**`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")
}
}
```
# PHP AWS SDK を使用して Secrets Manager シークレット値を取得する
PHP アプリケーションの場合は、[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) または [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) を使用して SDK を直接呼び出します。
次の例で、Secrets Manager シークレットの値を取得する方法を示します。
**必要な許可:**`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
```
# Ruby AWS SDK を使用して Secrets Manager のシークレット値を取得する
Ruby アプリケーションの場合は、[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) または [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) を使用して SDK を直接呼び出します。
次の例で、Secrets Manager シークレットの値を取得する方法を示します。
**必要な許可:**`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
```
# を使用してシークレット値を取得する AWS CLI
**必要な許可:**`secretsmanager:GetSecretValue`
**Example シークレットの暗号化されたシークレット値を取得する**
次の [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) の例では、現在のシークレット値が取得されます。
```
aws secretsmanager get-secret-value \
--secret-id MyTestSecret
```
**Example 前のシークレット値を取得する**
次の [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) の例では、前のシークレット値が取得されます。
```
aws secretsmanager get-secret-value \
--secret-id MyTestSecret
--version-stage AWSPREVIOUS
```
## を使用してバッチ内のシークレットのグループを取得する AWS CLI
**必要な許可:**
+ `secretsmanager:BatchGetSecretValue`
+ 取得するシークレットごとに `secretsmanager:GetSecretValue` のアクセス許可が必要です。
+ フィルターを使用する場合は、`secretsmanager:ListSecrets` も必要です。
アクセス許可ポリシーの例については、「[例: バッチでシークレット値のグループを取得するためのアクセス許可](auth-and-access_iam-policies.md#auth-and-access_examples_batch)」を参照してください。
**重要**
取得しようとしているグループ内の個別シークレットを取得するためのアクセス許可を拒否する VPCE ポリシーを設定している場合、`BatchGetSecretValue` はシークレット値を返さず、エラーが返されます。
**Example 名前順に表示されたシークレットグループのシークレット値を取得する**
次の [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) の例では、3 つのシークレットのシークレット値を取得します。
```
aws secretsmanager batch-get-secret-value \
--secret-id-list MySecret1 MySecret2 MySecret3
```
**Example フィルターで選択したシークレットグループのシークレット値を取得する**
次の [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) の例では、「Test」という名前のタグが付いたシークレットのシークレット値を取得します。
```
aws secretsmanager batch-get-secret-value \
--filters Key="tag-key",Values="Test"
```
# AWS コンソールを使用してシークレット値を取得する
**シークレットを取得するには (コンソール)**
1. Secrets Manager のコンソール ([https://console.aws.amazon.com/secretsmanager/](https://console.aws.amazon.com/secretsmanager/)) を開きます。
1. シークレットのリストで、取得するシークレットを選択します。
1. **[シークレット値]** セクションで、**[シークレット値の取得]** を選択します。
Secrets Manager にシークレットの現在のバージョン (`AWSCURRENT`) が表示されます。シークレットの[他のバージョン](whats-in-a-secret.md#term_version) (`AWSPREVIOUS` やカスタムラベル付きバージョンなど) を表示するには、[を使用してシークレット値を取得する AWS CLI](retrieving-secrets_cli.md) を使用します。
# で AWS Secrets Manager シークレットを使用する AWS Batch
AWS Batch は、 でバッチコンピューティングワークロードを実行するのに役立ちます AWS クラウド。を使用すると AWS Batch、機密データを AWS Secrets Manager シークレットに保存し、ジョブ定義で参照することで、機密データをジョブに挿入できます。詳細については、「[Secrets Manager を使用した機密データの指定](https://docs.aws.amazon.com/batch/latest/userguide/specifying-sensitive-data-secrets.html)」を参照してください。
# CloudFormation リソースで AWS Secrets Manager シークレットを取得する
を使用すると CloudFormation、別の CloudFormation リソースで使用するシークレットを取得できます。一般的なシナリオでは、まず シークレットマネージャーが生成したパスワードを使ってシークレットを作成し、次に、シークレットから、新しいデータベースの認証情報として使用するユーザーネームとパスワードを取得します。でシークレットを作成する方法については CloudFormation、「」を参照してください[で AWS Secrets Manager シークレットを作成する AWS CloudFormation](cloudformation.md)。
CloudFormation テンプレートでシークレットを取得するには、*動的リファレンス*を使用します。スタックを作成すると、動的リファレンスはシークレット値を CloudFormation リソースにプルするため、シークレット情報をハードコードする必要はありません。代わりに、シークレットを名前または ARN で参照します。ダイナミックリファレンスは、任意のリソースプロパティ内のシークレットに対し使用できます。リソースメタデータ ([https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-init.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-init.html) など) 内にあるシークレットに対しては、ダイナミックリファレンスを使用することはできません。これにより、シークレット値がコンソールに表示されてしまうためです。
シークレットに対するダイナミックリファレンスのパターンを、次に示します。
```
{{resolve:secretsmanager:secret-id:SecretString:json-key:version-stage:version-id}}
```
**シークレットID**
シークレット名またはシークレット ARN。 AWS アカウントのシークレットにアクセスするには、シークレット名を使用できます。別の AWS アカウントのシークレットにアクセスするには、シークレットの ARN を使用します。
**json-key** (オプション)
値を取得するペアのキー名を指定します。を指定しない場合`json-key`、 はシークレットテキスト全体 CloudFormation を取得します。このセグメントにはコロン文字 (`:`) を含めることはできません。
**version-stage** (オプション)
使用するクエリの[バージョン](whats-in-a-secret.md#term_version) シークレットマネージャーは、ステージングラベルがローテーション処理中にさまざまなバージョンを追跡するために使用されます。`version-stage` を使用する場合は、`version-id` を指定することはできません。`version-stage` または `version-id`、を指定しない場合、デフォルトでは `AWSCURRENT` というラベルの付いたバージョンが取得されます。このセグメントにはコロン文字 (`:`) を含めることはできません。
**version-id** (オプション)
使用したいシークレットのバージョンの固有識別子を指定します。`version-id` を指定した場合は、`version-stage` を指定しないでください。`version-stage` または `version-id` を指定しない場合、次にデフォルトでは `AWSCURRENT` というバージョンが取得されます。このセグメントにはコロン文字 (`:`) を含めることはできません。
詳細については、「[シークレットマネージャーのシークレットを指定するための、ダイナミックレファレンスを使用する](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/dynamic-references.html#dynamic-references-secretsmanager)」を参照してください。
**注記**
最終値`(\)`としてバックスラッシュを使用して動的参照を作成しないでください。 CloudFormation はこれらの参照を解決できないため、リソースに障害が発生します。
# GitHub ジョブで AWS Secrets Manager シークレットを使用する
GitHub ジョブでシークレットを使用するには、GitHub アクションを使用して からシークレットを取得し AWS Secrets Manager 、GitHub ワークフローでマスクされた[環境変数](https://docs.github.com/en/actions/learn-github-actions/environment-variables)として追加できます。GitHub アクションの詳細については、GitHub ドキュメントの「[Understanding GitHub Actions](https://docs.github.com/en/actions/learn-github-actions/understanding-github-actions)」(GitHub アクションについて) を参照してください。
GitHub 環境にシークレットを追加すると、GitHub ジョブの他のすべてのステップでもそのシークレットが使用できるようになります。環境内のシークレットが悪用されるのを防ぐには、「[Security hardening for GitHub Actions](https://docs.github.com/en/actions/security-guides/security-hardening-for-github-actions)」(GitHub アクションのセキュリティ強化) のガイダンスに従ってください。
シークレット値の文字列全体を環境変数値として設定できます。また、文字列が JSON の場合は、JSON を解析して JSON キーと値のペアごとに環境変数を設定することもできます。シークレット値がバイナリの場合は文字列に変換されます。
シークレットから作成された環境変数を表示するには、デバッグログを有効にします。詳細については、*GitHub Docs* の「[デバッグログの有効化](https://docs.github.com/en/actions/monitoring-and-troubleshooting-workflows/enabling-debug-logging)」を参照してください。
シークレットから作成された環境変数を使用するには、GitHub Docs の「[環境変数](https://docs.github.com/en/actions/learn-github-actions/environment-variables)」を参照してください。
## 前提条件
このアクションを使用するには、まず AWS 認証情報を設定し、 `configure-aws-credentials` ステップを使用して GitHub AWS リージョン 環境で を設定する必要があります。**GitHub OIDC プロバイダを使用して直接ロールを引き受ける**には、「[GitHub アクションの AWS 認証情報アクションの設定](https://github.com/aws-actions/configure-aws-credentials)」の指示に従ってください。これにより、有効期間の短い認証情報を使用でき、追加のアクセスキーを Secrets Manager の外部に保存する必要がなくなります。
アクションが引き受ける IAM ロールには、以下のアクセス許可が必要です。
+ 取得するシークレットに対する `GetSecretValue`
+ すべてのシークレットに対する `ListSecrets`
+ (オプション) シークレットが で暗号化 KMS key されている場合は、 `Decrypt`の カスタマー管理キー。
詳細については、「[の認証とアクセスコントロール AWS Secrets Manager](auth-and-access.md)」を参照してください。
## 使用方法
アクションを使用するには、次の構文を使用するステップをワークフローに追加します。
```
- 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
```パラメータ
`secret-ids`
シークレット ARN、名前、名前プレフィックス。
環境変数名を設定するには、まず環境変数名を入力し、その後にシークレット ID とカンマを順に入力します。例えば、`ENV_VAR_1, secretId` はシークレット `secretId` から **ENV\$1VAR\$11** という名前の環境変数を作成します。環境変数名には、大文字の英字、数字、およびアンダースコアを使用できます。
プレフィックスを使用するには、3 文字以上を入力し、その後にアスタリスクを付けます。例えば、`dev*` は名前が **dev** で始まるすべてのシークレットに一致します。取得できる一致シークレットの最大数は 100 です。変数名を設定し、プレフィックスが複数のシークレットと一致する場合、アクションは失敗します。
`name-transformation`
デフォルトでは、このステップはシークレット名から各環境変数名を作成し、大文字の英字、数字、アンダースコアのみが含まれるように変換し、数字で始まらないようにします。名前の文字には、`lowercase` で小文字を使用するか、`none` で大文字と小文字を変更しないようにステップを設定できます。デフォルト値は `uppercase` です。
`parse-json-secrets`
(オプション) デフォルトでは、環境変数値がシークレット値内の JSON 文字列全体に設定されます。`parse-json-secrets` を `true` に設定すると、JSON 内のキーと値のペアごとに環境変数が作成されます。
「name」や「Name」など JSON で使用されるキーが大文字と小文字を区別する場合、アクション名が重複して競合することに注意してください。この場合は、`parse-json-secrets` を `false` に設定し、JSON シークレット値を別途解析します。
## 環境変数の命名
アクションによって作成された環境変数の名前は、その変数の元となるシークレットと同じになります。環境変数にはシークレットよりも厳しい命名要件があるため、そうした要件を満たすようにシークレット名が変換されます。例えば、小文字は大文字に変換されます。シークレットの JSON を解析する場合、環境変数名にはシークレット名と JSON キー名の両方が含まれます。(例えば `MYSECRET_KEYNAME`)。小文字を変換しないようにアクションを設定できます。
2 つの環境変数が同じ名前で終わると、アクションは失敗します。そのため、環境変数に使用する名前を*エイリアス*として指定する必要があります。
名前が競合する可能性がある場合:
+ 例えば、「MySecret」という名前のシークレットと「mysecret」という名前のシークレットはどちらも「MYSECRET」という名前の環境変数になります。
+ 「Secret\$1keyname」という名前のシークレットと、「keyname」という名前のキーを持つ「Secret」という名前の JSON 解析されたシークレットは、どちらも「SECRET\$1KEYNAME」という名前の環境変数になります。
次の例に示すように、`ENV_VAR_NAME` という名前の変数を作成する*エイリアス*を指定することで、環境変数名を設定できます。
```
secret-ids: |
ENV_VAR_NAME, secretId2
```
**空のエイリアス**
+ `parse-json-secrets: true` を設定して、空のエイリアスを入力し、次にカンマ、シークレット ID の順に入力すると、アクションは環境変数に解析された JSON キーと同じ名前を付けます。変数名にはシークレット名は含まれません。
シークレットに有効な JSON が含まれていない場合、アクションは 1 つの環境変数を作成し、シークレット名と同じ名前を付けます。
+ `parse-json-secrets: false` を設定して、空のエイリアスを入力し、次にカンマとシークレット ID の順に入力すると、アクションは環境変数にエイリアスを指定しなかった場合と同じように名前を付けます。
次の例は、空のエイリアスを示しています。
```
,secret2
```
## 例
**Example 1 名前と ARN でシークレットを取得する**
次の例では、名前と 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
```
作成された環境変数
```
EXAMPLESECRETNAME: secretValue1
TEST1: secretValue2
_0_TEST_SECRET: secretValue3
_PROD_EXAMPLE_SECRET: secretValue4
SECRET_ALIAS_1: secretValue5
SECRET_ALIAS_2: secretValue6
SECRET2: secretValue7
```
**Example 2 プレフィックスで始まるシークレットをすべて取得する**
次の例では、名前が *beta* で始まるすべてのシークレットの環境変数を作成しています。
```
- name: Get Secret Names by Prefix
uses: 2
with:
secret-ids: |
beta* # Retrieves all secrets that start with 'beta'
```
作成された環境変数
```
BETASECRETNAME: secretValue1
BETATEST: secretValue2
BETA_NEWSECRET: secretValue3
```
**Example 3 シークレット内の JSON を解析する**
次の例では、シークレット内の JSON を解析して環境変数を作成しています。
```
- 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
```
シークレット `test/secret` には、次のシークレット値があります。
```
{
"api_user": "user",
"api_key": "key",
"config": {
"active": "true"
}
}
```
シークレット `secret2` には、次のシークレット値があります。
```
{
"myusername": "alejandro_rosalez",
"mypassword": "EXAMPLE_PASSWORD"
}
```
作成された環境変数
```
TEST_SECRET_API_USER: "user"
TEST_SECRET_API_KEY: "key"
TEST_SECRET_CONFIG_ACTIVE: "true"
MYUSERNAME: "alejandro_rosalez"
MYPASSWORD: "EXAMPLE_PASSWORD"
```
**Example 4 環境変数名に小文字を使用する**
次の例では、小文字の名前で環境変数を作成します。
```
- name: Get secrets
uses: aws-actions/aws-secretsmanager-get-secrets@v2
with:
secret-ids: exampleSecretName
name-transformation: lowercase
```
作成された環境変数:
```
examplesecretname: secretValue
```
# GitLab AWS Secrets Manager で を使用する
AWS Secrets Manager は GitLab と統合されています。Secrets Manager シークレットを活用して GitLab 認証情報を保護し、GitLab でハードコードされなくなるようにします。代わりに、アプリケーションが GitLab CI/CD パイプラインでジョブを実行すると、[GitLab Runner](https://docs.gitlab.com/runner/) は Secrets Manager からこれらのシークレットを取得します。
この統合を使用するには、IAM と [IAM ロールに OpenID Connect (OIDC) ID プロバイダー](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_create_oidc.html) AWS Identity and Access Management を作成します。これにより、GitLab Runner は Secrets Manager シークレットにアクセスできるようになります。GitLab CI/CD と OIDC の詳細については、「[GitLab ドキュメント](https://docs.gitlab.com/ci/cloud_services/aws/)」を参照してください。
## 考慮事項
非公開の GitLab インスタンスを使用している場合、この Secrets Manager 統合を使用することはできません。代わりに、[非パブリックインスタンスに関する GitLab のドキュメント](https://docs.gitlab.com/ci/cloud_services/aws/#configure-a-non-public-gitlab-instance)を参照してください。
## 前提条件
Secrets Manager を GitLab と統合するには、次の前提条件を完了します。
1.
**AWS Secrets Manager シークレットを作成する**
GitLab ジョブで取得され、これらの認証情報をハードコードする必要がなくなる Secrets Manager シークレットが必要です。[GitLab パイプラインを設定する](#configure-gitlab-pipeline)ときは、Secrets Manager シークレット ID が必要です。詳細については「[AWS Secrets Manager シークレットを作成する](create_secret.md)」を参照してください。
1.
**IAM コンソールで GitLab を OIDC プロバイダーにします。**
このステップでは、IAM コンソールで GitLab を OIDC プロバイダーにします。詳細については、「[OpenID Connect (OIDC) ID プロバイダーの作成](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_providers_create_oidc.html)」および「[GitLab ドキュメント](https://docs.gitlab.com/ci/cloud_services/aws/)」を参照してください。
IAM コンソールで OIDC プロバイダーを作成するときは、次の設定を使用します。
1. `provider URL` を GitLab インスタンスに設定します。例えば、**gitlab.example.com** です。
1. `audience` または `aud` を **sts.amazonaws.com** に設定します。
1.
**IAM ポリシーとロールを作成する**
IAM ロールとポリシーを作成する必要があります。このロールは [AWS Security Token Service (STS)](https://docs.aws.amazon.com/STS/latest/APIReference/welcome.html) を使用する GitLab によって引き受けられます。詳細については、「[カスタム信頼ポリシーを使用してロールを作成する](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-custom.html)」を参照してください。
1. IAM コンソールで、IAM ロールを作成するときに次の設定を使用します。
+ `Trusted entity type` を **Web identity** に設定します。
+ `Group` を **your GitLab group** に設定します。
+ ステップ 2 で使用したものと同じプロバイダー URL ([GitLab インスタンス](#step2-oidc-provider)) に `Identity provider` を設定します。
+ ステップ 2 で使用したものと同じ[対象者](#step2-oidc-audience)に `Audience` を設定します。
1. 次に示すのは、GitLab がロールを引き受けることを許可する信頼ポリシーの例です。信頼ポリシーには AWS アカウント、、GitLab URL、および[プロジェクトパス](https://docs.gitlab.com/user/project/)がリストされている必要があります。
****
```
{
"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. また、GitLab に AWS Secrets Managerへのアクセスを許可する IAM ポリシーを作成する必要があります。このポリシーを信頼ポリシーに追加できます。詳細については、「[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"
}
]
}
```
## GitLab AWS Secrets Manager との統合
前提条件を完了したら、Secrets Manager を使用して認証情報を保護するように GitLab を設定できます。
### Secrets Manager を使用するように GitLab パイプラインを設定する
[GitLab CI/CD 設定ファイル](https://docs.gitlab.com/ci/yaml/yaml_optimization/)を以下の情報で更新する必要があります。
+ STS に設定されたトークンの対象者。
+ Secrets Manager のシークレット ID。
+ GitLab パイプラインでジョブを実行するときに GitLab Runner が引き受ける IAM ロール。
+ シークレットが保存され AWS リージョン ている 。
GitLab は Secrets Manager からシークレットを取得し、その値を一時ファイルに保存します。このファイルへのパスは、[ファイルタイプ CI/CD 変数](https://docs.gitlab.com/ci/variables/#use-file-type-cicd-variables)と同様に CI/CD 変数に保存されます。
以下は、GitLab CI/CD 設定ファイルの YAML ファイルのスニペットです。
```
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"
```
詳細については、「[GitLab Secrets Manager 統合のドキュメント](https://docs.gitlab.com/ci/secrets/aws_secrets_manager/)」を参照してください。
必要に応じて、GitLab で OIDC 設定をテストできます。詳細については、「[OIDC 設定のテストに関する GitLab のドキュメント](https://docs.gitlab.com/ci/cloud_services/aws/#test-the-oidc-configuration)」を参照してください。
## トラブルシューティング
以下は、Secrets Manager を GitLab と統合するときに発生する可能性がある一般的な問題のトラブルシューティングに役立ちます。
### GitLab Pipeline の問題
GitLab パイプラインの問題が発生した場合は、以下を確認してください。
+ YAML ファイルが適切にフォーマットされている。詳細については、「[GitLab のドキュメント](https://docs.gitlab.com/ee/ci/yaml/)」を参照してください。
+ GitLab パイプラインは正しいロールを引き受けており、適切なアクセス許可と正しい AWS Secrets Manager シークレットへのアクセスを持っています。
### その他のリソース
以下のリソースは、GitLab と AWS Secrets Managerに関する問題のトラブルシューティングに役立ちます。
+ [GitLab OIDC のトラブルシューティング](https://docs.gitlab.com/ci/cloud_services/aws/#troubleshooting)
+ [GitLab CI/CD パイプラインのデバッグ](https://docs.gitlab.com/ee/ci/troubleshooting.html)
+ [トラブルシューティング](ascp-eks-installation.md#troubleshooting)
# で AWS Secrets Manager シークレットを使用する AWS IoT Greengrass
AWS IoT Greengrass は、クラウド機能をローカルデバイスに拡張するソフトウェアです。これにより、デバイスは情報源に近いデータを収集および分析して、ローカルイベントに自動的に反応し、ローカルネットワークで互いに安全に通信することができます。
AWS IoT Greengrass では、パスワード、トークン、またはその他のシークレットをハードコーディングすることなく、 AWS IoT Greengrass デバイスからサービスやアプリケーションで認証できます。 AWS Secrets Manager を使用して、シークレットをクラウドに安全に保存および管理できます。 は Secrets Manager を AWS IoT Greengrass コアデバイスに AWS IoT Greengrass 拡張するため、コネクタと Lambda 関数はローカルシークレットを使用してサービスやアプリケーションとやり取りできます。
シークレットを AWS IoT Greengrass グループに統合するには、Secrets Manager シークレットを参照するグループリソースを作成します。このシークレットリソースは、関連付けられた ARN を使用してクラウドシークレットを参照します。シークレットリソースを作成、管理、使用する方法については、 AWS IoT デベロッパーガイドの[「シークレットリソースの使用](https://docs.aws.amazon.com/greengrass/latest/developerguide/secrets-using.html)」を参照してください。
シークレットを AWS IoT Greengrass Core にデプロイするには、「シーク[レットを Core にデプロイする AWS IoT Greengrass 」を参照してください。](https://docs.aws.amazon.com/greengrass/latest/developerguide/secrets.html)
# パラメータストアで AWS Secrets Manager シークレットを使用する
AWS Systems Manager パラメータストアは、設定データ管理とシークレット管理のための安全な階層型ストレージを提供します。パスワード、データベース文字列、およびライセンスコードなどのデータをパラメータ値として保存することができます。ただし、パラメータストアは保存されるシークレットの自動ローテーションサービスを提供していません。代わりに、パラメータストアを使用して、Secrets Manager にシークレットを保存することができ、パラメータストアのパラメータとしてそのシークレットを参照できます。
Secrets Manager を使用してパラメータストアを設定する場合、`secret-id` パラメータストアでは、名前文字列の前にスラッシュ (/) が必要です。
詳細については、「 *AWS Systems Manager ユーザーガイド*」の[「パラメータストアパラメータからの AWS Secrets Manager シークレットの参照](https://docs.aws.amazon.com/systems-manager/latest/userguide/integration-ps-secretsmanager.html)」を参照してください。