翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。
# ロールベースのアクセスコントロール (RBAC)
「[Valkey および Redis OSS AUTH コマンドによる認証](auth.md)」で説明されているように Valkey および Redis OSS の AUTH コマンドを使用すると、ロールベースのアクセスコントロール (RBAC) を使用できます。RBAC は、サーバーレスキャッシュへのアクセスを制御する唯一の手段でもあります。これは、Valkey 7.2 以降と Redis OSS 6.0～7.2 で利用できます。
RBAC により、以下のことが可能になります。
+ ユーザーグループによってキャッシュへのアクセスを制御する。ユーザーグループは、キャッシュへのアクセスを分類する手段として設計されています。
+ *認証*で、クラスターごとの認証トークンではなく、ユーザーごとのパスワードを使用する。
+ *認可*で、きめ細かなユーザーアクセス許可を使用する。
+ ACL に基づいてクラスターにアクセスする。
Valkey および Redis OSS の AUTH では、クライアントのトークンが認証されていれば、認証済みのすべてのクライアントにキャッシュへのフルアクセスが認められますが、RBAC はこれとは異なり、ユーザーが必要とするロールに応じたセットにユーザーを割り当てることができます。このセットは、キャッシュへのアクセスを分類する手段として設計されています。
RBAC では、以下で説明されているように、アクセス文字列を使用してユーザーを作成し、ユーザーに特定のアクセス許可を割り当てます。特定のロール (管理者、人事) に対応したセットにユーザーを割り当てると、そのセットが 1 つ以上の ElastiCache キャッシュにデプロイされます。これにより、同じ Valkey または Redis OSS キャッシュを使用するクライアント間にセキュリティ境界を設定し、クライアントが互いのデータにアクセスできないようにすることができます。
RBAC は、Redis OSS 6 の [ACL](https://valkey.io/topics/acl/) の導入をサポートするように設計されています。ElastiCache Valkey または Redis OSS キャッシュで RBAC を使用する場合、いくつかの制限があります。
+ VALKEY エンジン用に設定されたユーザーグループに含めることができるのは、認証メカニズム (パスワードまたは IAM) を使用しているユーザーのみです。つまり、VALKEY エンジンを使用するすべてのユーザーと、Redis エンジンを使用するその他のユーザーのうち、パスワードまたは IAM で認証するように設定されているユーザーをこのユーザーグループに含めることができます。
+ Valkey クラスターで RBAC を使用する場合、エンジンが VALKEY のユーザーグループとエンジンが REDIS のユーザーグループのどちらも使用できます。
+ Redis OSS クラスターで RBAC を使用する場合、エンジンが REDIS のユーザーグループのみを使用できます。
+ アクセス文字列にパスワードを指定することはできません。パスワードは [CreateUser](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_CreateUser.html) または [ModifyUser](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyUser.html) コールで設定します。
+ ユーザー権限については、`on` と `off` をアクセス文字列の一部として指定することで、ユーザーを有効または無効にします。アクセス文字列にどちらも指定されていない場合、ユーザーには `off` が割り当てられ、キャッシュへのアクセス権はありません。
+ 禁止または名前変更されたコマンドをアクセス文字列の一部として使用することはできません。禁止または名前変更されたコマンドを指定すると、例外がスローされます。名前を変更したコマンドでアクセスコントロールリスト (ACL) を使用する場合は、コマンドの元の名前、つまり名前が変更される前のコマンドの名前を指定します。
+ `reset` コマンドを、アクセス文字列の一部として使用することはできません。API パラメータを用いてパスワードを指定すると、ElastiCache for Valkey と ElastiCache for Redis OSS がパスワードを管理します。したがって、`reset` を使用することはできません。それによりユーザーのすべてのパスワードが削除されるからです。
+ Redis OSS 6 は、[ACL LIST](https://valkey.io/commands/acl-list) コマンドを導入します。このコマンドは、ユーザーのリストと、各ユーザーに適用される ACL ルールを返します。ElastiCache は `ACL LIST` コマンドをサポートしますが、Redis OSS のようにパスワードハッシュのサポートは含まれていません。ElastiCache では、[DescribeUsers](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeUsers.html) オペレーションを使用して、アクセス文字列に含まれるルールなど、同様の情報を取得できます。ただし、[DescribeUsers](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeUsers.html) は、ユーザーパスワードを取得しません。
+ ElastiCache for Valkey と ElastiCache for Redis OSS でサポートされているその他の読み取り専用コマンドには、[ACL WHOAMI](https://valkey.io/commands/acl-whoami)、[ACL USERS](https://valkey.io/commands/acl-users)、[ACL CAT](https://valkey.io/commands/acl-cat) などがあります。ElastiCache for Valkey と ElastiCache for Redis OSS は、他の書き込みベースの ACL コマンドをサポートしません。
+ 以下の制限が適用されます。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/AmazonElastiCache/latest/dg/Clusters.RBAC.html)
**Valkey を使用した RBAC**
Valkey でロールベースのアクセスコントロールを使用する場合、ユーザーとユーザーグループは VALKEY エンジンタイプで作成されます。これが推奨されます。デフォルトでは、RBAC で Valkey を使用すると、Redis OSS を使用する場合と比較してセキュリティが向上するためです。プロビジョニングされた Valkey クラスターとサーバーレス Valkey クラスターはどちらも、VALKEY ユーザーおよびユーザーグループの関連付けをサポートします。
Valkey によるアクセスコントロールの主な機能は次のとおりです。
+ Valkey ユーザーは、Valkey ユーザーグループの関連付けのみに制限されます。
+ Valkey ユーザーグループには、Valkey ユーザーと、パスワードで保護されているか IAM 認証が有効になっている Redis OSS ユーザーを含めることができます。
+ Valkey ユーザーは、パスワード保護または IAM 認証を使用する必要があります。
+ VALKEY ユーザーグループは、VALKEY クラスターにのみ関連付けることができます
+ デフォルトユーザーの要件はありません。Valkey ユーザーグループがクラスターにアタッチされると、デフォルトユーザーの要件は自動的に無効になります。ACL LIST コマンドを使用すると、デフォルトユーザーがオフになっていることがわかります。
ElastiCache for Valkey と ElastiCache for Redis OSS での RBAC の使用の詳細については、以下を参照してください。
**Topics**
+ [アクセス文字列を使用したアクセス許可の指定](#Access-string)
+ [ElastiCache for Valkey または ElastiCache for Redis OSS のキャッシュに RBAC を適用する](#rbac-using)
+ [AUTH から RBAC への移行](#Migrate-From-RBAC-to-Auth)
+ [RBAC から AUTH への移行](#Migrate-From-RBAC-to-AUTH-1)
+ [ユーザーのパスワードの自動ローテーション](User-Secrets-Manager.md)
+ [IAM を使用した認証](auth-iam.md)
## アクセス文字列を使用したアクセス許可の指定
ElastiCache Valkey または Redis OSS キャッシュへのアクセス許可を指定するには、アクセス文字列を作成し、AWS CLIまたは を使用してユーザーに割り当てますAWS マネジメントコンソール。
アクセス文字列は、ユーザーに適用されるスペース区切りルールのリストとして定義されます。それらは、ユーザーが実行できるコマンドと、ユーザーが操作できるキーを定義します。コマンドを実行するには、ユーザーは、実行されているコマンドと、そのコマンドによってアクセスされているすべてのキーにアクセスできる必要があります。ルールは左から右に累積的に適用され、提供された文字列に冗長性がある場合は、提供された文字列の代わりに、より単純な文字列を使用できます。
ACL ルールの構文の詳細については、「[ACL](https://valkey.io/topics/acl/)」を参照してください。
次の例では、アクセス文字列は、使用可能なすべてのキーおよびコマンドにアクセスできるアクティブなユーザーを表します。
`on ~* +@all`
アクセス文字列の構文は、次のように分類されます。
+ `on` — ユーザーはアクティブなユーザーです。
+ `~*` — アクセス権はすべての使用可能なキーに与えられます。
+ `+@all` — アクセス権はすべての使用可能なコマンドに与えられます。
上記の設定は、最も制限が緩い設定です。これらの設定を変更して、セキュリティを強化できます。
次の例では、アクセス文字列は「app::」キースペースで始まるキーに対する読み取りアクセスに制限されたアクセス権を持つユーザーを表します。
`on ~app::* -@all +@read`
ユーザーがアクセス権を持つコマンドを一覧表示することで、これらのアクセス許可をさらに絞り込むことができます。
`+command1` — ユーザーのコマンドへのアクセスは *`command1`* に制限されます。
`+@category` — ユーザーのアクセスは、コマンドのカテゴリーに制限されます。
アクセス文字列をユーザーに割り当てる方法については、「[コンソールと CLI を使用したユーザーおよびユーザーグループの作成](#Users-management)」を参照してください。
既存のワークロードを ElastiCache に移行する場合は、`ACL LIST` を呼び出すことでアクセス権を取得して、ユーザーおよびパスワードハッシュを除外できます。
Redis OSS バージョン 6.2 以降では、以下のアクセス文字列構文もサポートされています。
+ `&*` — アクセス権はすべての使用可能なチャネルに与えられます。
Redis OSS バージョン 7.0 以降では、以下のアクセス文字列構文もサポートされています。
+ `|` — サブコマンドをブロックするために使用できます (例:「-config\$1set」)。
+ `%R~` — 指定された読み取りキーパターンを追加します。これは通常のキーパターンと同様に動作しますが、指定されたパターンに一致するキーからの読み取り権限のみを許可します。詳細については、「[キーのアクセス許可](https://valkey.io/topics/acl/)」を参照してください。
+ `%W~` — 指定された書き込みキーパターンを追加します。これは通常のキーパターンと同様に動作しますが、指定されたパターンに一致するキーに書き込む権限のみを許可します。詳細については、「[ACL key permissions](https://valkey.io/topics/acl/)」を参照してください。
+ `%RW~` – `~` のエイリアス。
+ `()` — ルールを照合する新しいセレクターを作成します。セレクターはユーザーアクセス許可の後に評価され、定義されている順序に従って評価されます。コマンドがユーザーアクセス許可または任意のセレクターと一致する場合、そのコマンドは許可されます。詳細については、[ACL セレクター](https://valkey.io/topics/acl/)を参照してください。
+ `clearselectors` — ユーザーにアタッチされているセレクターをすべて削除します。
## ElastiCache for Valkey または ElastiCache for Redis OSS のキャッシュに RBAC を適用する
ElastiCache for Valkey または ElastiCache for Redis OSS の RBAC を使用するには、次のステップに従います。
1. 1 つ以上のユーザーを作成します。
1. ユーザーグループを作成し、ユーザーをグループに追加します。
1. 転送時の暗号化が有効なキャッシュにユーザーグループを割り当てます。
これらのステップについては、以下で詳しく説明します。
**Topics**
+ [コンソールと CLI を使用したユーザーおよびユーザーグループの作成](#Users-management)
+ [コンソールおよび CLI を使用したユーザーグループの管理](#User-Groups)
+ [サーバーレスキャッシュへのユーザーグループの割り当て](#Users-groups-to-serverless-caches)
+ [レプリケーショングループへのユーザーグループの割り当て](#Users-groups-to-RGs)
### コンソールと CLI を使用したユーザーおよびユーザーグループの作成
RBAC ユーザーのユーザー情報は、ユーザー ID、ユーザー名、およびオプションのパスワードとアクセス文字列です。アクセス文字列は、キーとコマンドでのアクセス許可レベルを提供します。ユーザー ID はユーザーに対して一意であり、ユーザー名はエンジンに渡されるものです。
指定するユーザー許可が、ユーザーグループの意図した目的に合っていることを確認してください。たとえば、`Administrators` という名前のユーザーグループを作成した場合、そのグループに追加するすべてのユーザーは、キーおよびコマンドへのフルアクセスに設定されたアクセス文字列を持つ必要があります。`e-commerce` ユーザーグループ内のユーザーでは、アクセス文字列を読み取り専用アクセスに設定できます。
ElastiCache は、ユーザー ID とユーザー名 `"default"` を使用してデフォルトユーザーを自動的に設定し、それをすべてのユーザーグループに追加します。このユーザーを変更または削除することはできません。このユーザーは、以前の Redis OSS バージョンのデフォルト動作との互換性を意図して作成されており、すべてのコマンドを呼び出してすべてのキーにアクセスできるようにするアクセス文字列を持っています。
適切なアクセスコントロールをキャッシュに追加するには、このデフォルトユーザーを、有効になっていない、または強力なパスワードを使用する新しいユーザーに置き換えます。デフォルトユーザーを変更するには、ユーザー名が `default` に設定された新しいユーザーを作成します。その後、元のデフォルトユーザーと入れ替えることができます。
次の手順では、元の `default` ユーザーを、変更されたアクセス文字列を持つ別の `default` ユーザーと入れ替える方法を示します。
**コンソールでデフォルトユーザーを変更するには**
1. にサインインAWS マネジメントコンソールし、[https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/) で Amazon ElastiCache コンソールを開きます。
1. ナビゲーションペインで **[ユーザーグループの管理]** を選択します。
1. **[ユーザーグループ ID]** で、変更対象の ID を選択します。チェックボックスではなく、リンクを選択するようにしてください。
1. **[Modify]** (変更) を選択します。
1. **[変更]** ウィンドウで、**[管理]** を選択します。[目的のユーザーを選択する] で、その**ユーザー名**のユーザーをデフォルトとして選択します。
1. **選択** を選択します。
1. **[Modify]** (変更) を選択します。これを行うと、元のデフォルトユーザーが確立していたキャッシュへの既存の接続はすべて終了します。
**を使用してデフォルトユーザーを変更するにはAWS CLI**
1. 以下のコマンドを使用して、ユーザー名 `default` で新しいユーザーを作成します。
Linux、macOS、Unix の場合:
```
aws elasticache create-user \
--user-id "new-default-user" \
--user-name "default" \
--engine "VALKEY" \
--passwords "a-str0ng-pa))word" \
--access-string "off +get ~keys*"
```
Windows の場合:
```
aws elasticache create-user ^
--user-id "new-default-user" ^
--user-name "default" ^
--engine "VALKEY" ^
--passwords "a-str0ng-pa))word" ^
--access-string "off +get ~keys*"
```
1. ユーザーグループを作成し、前に作成したユーザーを追加します。
Linux、macOS、Unix の場合:
```
aws elasticache create-user-group \
--user-group-id "new-group-2" \
--engine "VALKEY" \
--user-ids "new-default-user"
```
Windows の場合:
```
aws elasticache create-user-group ^
--user-group-id "new-group-2" ^
--engine "VALKEY" ^
--user-ids "new-default-user"
```
ユーザーを作成するときは、最大 2 つのパスワードを設定できます。パスワードを変更しても、キャッシュへの既存の接続はすべて維持されます。
特に、ElastiCache for Valkey と ElastiCache for Redis OSS で RBAC を使用する場合は、以下のユーザーパスワードの制約に注意してください。
+ パスワードは、印刷可能な 16～128 文字にする必要があります。
+ 次の英数字以外の文字は使用できません: `,` `""` `/` `@`。
#### コンソールおよび CLI を使用したユーザーの管理
コンソール上でユーザーを管理するには、次の手順に従います。
**コンソールでユーザーを管理するには**
1. にサインインAWS マネジメントコンソールし、[https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/) で Amazon ElastiCache コンソールを開きます。
1. Amazon ElastiCache ダッシュボードで、**[ユーザー管理]** を選択します。次のオプションを使用できます。
+ **[ユーザーを作成]** — ユーザーの作成時に、ユーザー ID、ユーザー名、認証モード、およびアクセス文字列を入力します。アクセス文字列は、ユーザーが許可されたキーとコマンドのアクセス許可レベルを設定します。
ユーザーを作成するときは、最大 2 つのパスワードを設定できます。パスワードを変更しても、キャッシュへの既存の接続はすべて維持されます。
+ **[ユーザーを変更]** — ユーザーの認証設定を更新したり、アクセス文字列を変更したりできます。
+ **[ユーザーを削除]** — アカウントは、所属先のすべてのユーザーグループから削除されます。
AWS CLIでユーザーを管理するには、次の手順を使用します。
**CLI を使用してユーザーを変更するには**
+ `modify-user` コマンドを使用して、ユーザーのパスワードまたはパスワードを更新したり、ユーザーのアクセス権を変更したりします。
ユーザーが変更されると、そのユーザーに関連付けられたユーザーグループが更新され、そのユーザーグループに関連付けられたキャッシュも更新されます。既存の接続はすべて維持されます。以下は例です。
Linux、macOS、Unix の場合:
```
aws elasticache modify-user \
--user-id user-id-1 \
--access-string "~objects:* ~items:* ~public:*" \
--authentication-mode Type=iam
```
Windows の場合:
```
aws elasticache modify-user ^
--user-id user-id-1 ^
--access-string "~objects:* ~items:* ~public:*" ^
--authentication-mode Type=iam
```
**注記**
`nopass` オプションを使用することは推奨されません。その場合、ユーザーのアクセス許可を読み取り専用に設定して、限定されたキーのセットにアクセスすることをお勧めします。
**CLI を使用してサービスロールを削除するには**
+ ユーザーを削除するには、`delete-user` コマンドを使用します。アカウントが削除され、そのアカウントが属するユーザーグループから削除されます。以下に例を示します。
Linux、macOS、Unix の場合:
```
aws elasticache delete-user \
--user-id user-id-2
```
Windows の場合:
```
aws elasticache delete-user ^
--user-id user-id-2
```
ユーザーのリストを表示するには、[describe-users](https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-users.html) オペレーションを呼び出します。
```
aws elasticache describe-users
```
### コンソールおよび CLI を使用したユーザーグループの管理
次に示すように、ユーザーグループを作成して、1 つまたは複数のレプリケーショングループに対するユーザーのアクセスを分類および制御できます。
コンソールを使用してユーザーグループを管理するには、次の手順に従います。
**コンソールを使用してユーザーグループを管理するには**
1. にサインインAWS マネジメントコンソールし、[https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/) で Amazon ElastiCache コンソールを開きます。
1. Amazon ElastiCache ダッシュボードで、**[ユーザーグループの管理]** を選択します。
以下のオペレーションは、新しいユーザーグループを作成するために使用できます。
+ **[作成]** – ユーザーグループの作成時に、ユーザーを追加し、ユーザーグループをキャッシュに割り当てます。例えば、キャッシュで管理者ロールを持つユーザーの `Admin` ユーザーグループを作成できます。
**重要**
Valkey または Redis OSS ユーザーグループを使用していない場合は、ユーザーグループを作成するときにデフォルトユーザーを含める必要があります。
+ **[ユーザーの追加]** — ユーザーをユーザーグループに追加します。
+ **[ユーザーの削除]** — ユーザーグループからユーザーを削除します。ユーザーがユーザーグループから削除された場合、そのユーザーが確立しているキャッシュへの既存の接続はすべて終了します。
+ **[削除]** — ユーザーグループを削除します。グループに属するユーザーではなく、ユーザーグループ自体が削除されることに注意してください。
既存のユーザーグループでは、次のことを実行できます。
+ [**ユーザーの追加**] — 既存のユーザーをユーザーグループに追加します。
+ [**ユーザーを削除する**] — ユーザーグループから既存のユーザーを削除します。
**注記**
ユーザーはユーザーグループから削除されますが、システムからは削除されません。
次の手順で、CLI を使用してユーザーグループを管理します。
**CLI を使用して新しいユーザーグループを作成し、ユーザーを追加するには**
+ 次に示すように、`create-user-group` コマンドを使用します。
Linux、macOS、Unix の場合:
```
aws elasticache create-user-group \
--user-group-id "new-group-1" \
--engine "VALKEY" \
--user-ids user-id-1, user-id-2
```
Windows の場合:
```
aws elasticache create-user-group ^
--user-group-id "new-group-1" ^
--engine "VALKEY" ^
--user-ids user-id-1, user-id-2
```
**CLI を使用して新しいユーザーを追加するか、現在のメンバーを削除してユーザーグループを変更するには**
+ 次に示すように、`modify-user-group` コマンドを使用します。
Linux、macOS、Unix の場合:
```
aws elasticache modify-user-group --user-group-id new-group-1 \
--user-ids-to-add user-id-3 \
--user-ids-to-remove user-id-2
```
Windows の場合:
```
aws elasticache modify-user-group --user-group-id new-group-1 ^
--user-ids-to-add user-id-3 ^
--user-ids-to-removere user-id-2
```
**注記**
ユーザーグループから削除されたユーザーに属する開いている接続はすべて、このコマンドによって終了します。
**CLI を使用してターゲットグループを削除するには**
+ 次に示すように、`delete-user-group` コマンドを使用します。グループに属するユーザーではなく、ユーザーグループ自体が削除されます。
Linux、macOS、Unix の場合:
```
aws elasticache delete-user-group /
--user-group-id
```
Windows の場合:
```
aws elasticache delete-user-group ^
--user-group-id
```
ユーザーグループのリストを表示するには、[describe-user-groups](https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-user-groups.html) オペレーションを呼び出すことができます。
```
aws elasticache describe-user-groups \
--user-group-id test-group
```
### サーバーレスキャッシュへのユーザーグループの割り当て
ユーザーグループを作成してユーザーを追加した後、RBAC の実装手順の締めくくりとして、ユーザーグループをサーバーレスキャッシュに割り当てます。
#### コンソールを使用したサーバーレスキャッシュへのユーザーグループの割り当て
を使用してサーバーレスキャッシュにユーザーグループを追加するにはAWS マネジメントコンソール、次の手順を実行します。
+ クラスターモードが無効の場合は、「[Valkey (クラスターモードが無効) クラスターの作成 (コンソール)](SubnetGroups.designing-cluster-pre.valkey.md#Clusters.Create.CON.valkey-gs)」を参照してください。
+ クラスターモードが有効の場合は、「[Valkey または Redis OSS (クラスターモードが有効) クラスターの作成 (コンソール)](Clusters.Create.md#Clusters.Create.CON.RedisCluster)」を参照してください。
#### を使用したサーバーレスキャッシュへのユーザーグループの割り当てAWS CLI
次のAWS CLIオペレーションでは、値 の **user-group-id**パラメータを使用してサーバーレスキャッシュを作成します`my-user-group-id`。サブネット グループ `sng-test` を、実存のサブネットグループに置き換えます。
**主要パラメータ**
+ **--engine** — `VALKEY` または `REDIS` を指定する必要があります。
+ **--user-group-id** — この値には、キャッシュへの特定のアクセス許可を割り当てられたユーザーで構成されるユーザーグループの ID を指定します。
Linux、macOS、Unix の場合:
```
aws elasticache create-serverless-cache \
--serverless-cache-name "new-serverless-cache" \
--description "new-serverless-cache" \
--engine "VALKEY" \
--user-group-id "new-group-1"
```
Windows の場合:
```
aws elasticache create-serverless-cache ^
--serverless-cache-name "new-serverless-cache" ^
--description "new-serverless-cache" ^
--engine "VALKEY" ^
--user-group-id "new-group-1"
```
次のAWS CLIオペレーションでは、値 の **user-group-id**パラメータを使用してサーバーレスキャッシュを変更します`my-user-group-id`。
Linux、macOS、Unix の場合:
```
aws elasticache modify-serverless-cache \
--serverless-cache-name serverless-cache-1 \
--user-group-id "new-group-2"
```
Windows の場合:
```
aws elasticache modify-serverless-cache ^
--serverless-cache-name serverless-cache-1 ^
--user-group-id "new-group-2"
```
キャッシュに加えられた変更は、非同期で更新されます。イベントを表示して、この進行状況をモニタリングできます。詳細については、「[ElastiCache イベントの表示](ECEvents.Viewing.md)」を参照してください。
### レプリケーショングループへのユーザーグループの割り当て
ユーザーグループを作成してユーザーを追加した後、RBAC を実装する最後の手順では、ユーザーグループをレプリケーショングループに割り当てます。
#### コンソールを使用したレプリケーショングループへのユーザーグループの割り当て
を使用してレプリケーションにユーザーグループを追加するにはAWS マネジメントコンソール、次の手順を実行します。
+ クラスターモードが無効の場合は、「[Valkey (クラスターモードが無効) クラスターの作成 (コンソール)](SubnetGroups.designing-cluster-pre.valkey.md#Clusters.Create.CON.valkey-gs)」を参照してください。
+ クラスターモードが有効の場合は、「[Valkey または Redis OSS (クラスターモードが有効) クラスターの作成 (コンソール)](Clusters.Create.md#Clusters.Create.CON.RedisCluster)」を参照してください。
#### を使用したレプリケーショングループへのユーザーグループの割り当てAWS CLI
次のAWS CLIオペレーションでは、転送中の暗号化 (TLS) が有効になっているレプリケーショングループと、値 を持つ **user-group-ids**パラメータを作成します`my-user-group-id`。サブネット グループ `sng-test` を、実存のサブネットグループに置き換えます。
**主要パラメータ**
+ **--engine** — `valkey` または `redis` を指定する必要があります。
+ **--engine-version** - 6.0 以降を指定する必要があります。
+ **--transit-encryption-enabled** — 認証およびユーザーグループの関連付けに必要です。
+ **--user-group-ids** — この値には、キャッシュへの特定のアクセス許可を割り当てられたユーザーで構成されるユーザーグループの ID を指定します。
+ **--cache-subnet-group** — ユーザーグループを関連付けるために必要です。
Linux、macOS、Unix の場合:
```
aws elasticache create-replication-group \
--replication-group-id "new-replication-group" \
--replication-group-description "new-replication-group" \
--engine "VALKEY" \
--cache-node-type cache.m5.large \
--transit-encryption-enabled \
--user-group-ids "new-group-1" \
--cache-subnet-group "cache-subnet-group"
```
Windows の場合:
```
aws elasticache create-replication-group ^
--replication-group-id "new-replication-group" ^
--replication-group-description "new-replication-group" ^
--engine "VALKEY" ^
--cache-node-type cache.m5.large ^
--transit-encryption-enabled ^
--user-group-ids "new-group-1" ^
--cache-subnet-group "cache-subnet-group"
```
次のAWS CLIオペレーションでは、転送中の暗号化 (TLS) が有効になっているレプリケーショングループと、値 の **user-group-ids**パラメータを変更します`my-user-group-id`。
Linux、macOS、Unix の場合:
```
aws elasticache modify-replication-group \
--replication-group-id replication-group-1 \
--user-group-ids-to-remove "new-group-1" \
--user-group-ids-to-add "new-group-2"
```
Windows の場合:
```
aws elasticache modify-replication-group ^
--replication-group-id replication-group-1 ^
--user-group-ids-to-remove "new-group-1" ^
--user-group-ids-to-add "new-group-2"
```
レスポンス内の `PendingChanges` を書き留めます。キャッシュに加えられた変更は、非同期で更新されます。イベントを表示して、この進行状況をモニタリングできます。詳細については、「[ElastiCache イベントの表示](ECEvents.Viewing.md)」を参照してください。
## AUTH から RBAC への移行
「[Valkey および Redis OSS AUTH コマンドによる認証](auth.md)」で説明されているように、AUTH を使用していて RBAC の使用に移行するには、次の手順を使用します。
次の手順で、コンソールを使用して AUTH から RBAC に移行します。
**コンソールを使用して Valkey または Redis OSS の AUTH から RBAC に移行するには**
1. にサインインAWS マネジメントコンソールし、[https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/) で ElastiCache コンソールを開きます。
1. 右上隅のリストから、変更するキャッシュがあるAWSリージョンを選択します。
1. ナビゲーションペインで、変更対象のキャッシュで実行されているエンジンを選択します。
選択したエンジンのキャッシュのリストが表示されます。
1. キャッシュのリストで、変更対象のキャッシュの名前を選択します。
1. **[アクション]**、**[変更]** の順に選択します。
**[変更]** ウィンドウが表示されます。
1. **[アクセスコントロール]** で、**[ユーザーグループのアクセスコントロールリスト]** を選択します。
1. **[ユーザーグループのアクセスコントロールリスト]** で、ユーザーグループを選択します。
1. **[変更をプレビュー]** を選択し、次の画面で **[変更]** を選択します。
次の手順で、CLI を使用して Valkey または Redis OSS の AUTH から RBAC に移行します。
**CLI を使用して AUTH から RBAC に移行するには**
+ 次に示すように、`modify-replication-group` コマンドを使用します。
Linux、macOS、Unix の場合:
```
aws elasticache modify-replication-group --replication-group-id test \
--auth-token-update-strategy DELETE \
--user-group-ids-to-add user-group-1
```
Windows の場合:
```
aws elasticache modify-replication-group --replication-group-id test ^
--auth-token-update-strategy DELETE ^
--user-group-ids-to-add user-group-1
```
## RBAC から AUTH への移行
RBAC を使用していて、Redis OSS の AUTH に移行する場合は、「[RBAC から AUTH への移行](auth.md#Migrate-From-RBAC-to-AUTH)」を参照してください。
**注記**
ElastiCache キャッシュのアクセスコントロールを無効にする必要がある場合は、AWS CLIを使用して無効にする必要があります。詳細については、「[ElastiCache Valkey または Redis OSS キャッシュでアクセスコントロールを無効にする](in-transit-encryption-disable.md)」を参照してください。
# ユーザーのパスワードの自動ローテーション
を使用するとAWS Secrets Manager、コード内のハードコードされた認証情報 (パスワードを含む) を Secrets Manager への API コールに置き換えて、プログラムでシークレットを取得できます。シークレットはそこに存在しないため､これは、あなたのコードを調べている誰かがシークレットを漏らさないようにするのに役立ちます。また、指定したスケジュールに従って自動的にシークレットを更新するように Secrets Manager を設定することができます。これにより、長期のシークレットを短期のシークレットに置き換えることが可能となり、侵害されるリスクが大幅に減少します。
Secrets Manager を使用すると、Secrets Manager が提供するAWS Lambda関数を使用して、ElastiCache for Redis OSS パスワード (シークレット) を自動的にローテーションできます。
詳細についてはAWS Secrets Manager、[「 とは」を参照してくださいAWS Secrets Manager。](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html)
## ElastiCache がシークレットを使用する方法
Valkey 7.2 以降には、Redis OSS 7.0 と同等の機能セットがあります。Redis OSS 6 では、ElastiCache に Valkey または Redis OSS クラスターを保護するために [ロールベースのアクセスコントロール (RBAC)](Clusters.RBAC.md) が導入されました。この機能により、実行できるコマンドとアクセスできるキーに関して特定の接続を制限できます。RBAC では、顧客がパスワードを使用してユーザーを作成するときに、パスワードの値はプレーンテキストで手動により入力する必要があり、オペレーターに表示されます。
シークレットマネージャーを使用すると、アプリケーションはパスワードを手動で入力してアプリケーションの設定に保存するのではなく、シークレットマネージャーからパスワードを取得します。これを行う方法については、「[ElastiCache ユーザーをシークレットに関連付ける方法](#How-User-Secrets-Manager-Associate)」を参照してください。
シークレットの使用にはコストが発生します。料金情報については、「[AWS Systems Manager の料金](https://aws.amazon.com/secrets-manager/pricing/)」を参照してください。
## ElastiCache ユーザーをシークレットに関連付ける方法
シークレットマネージャーは、関連するユーザーのリファレンスをシークレットの `SecretString` フィールドに保存します。ElastiCache 側からのシークレットへの参照はありません。
```
{
"password": "strongpassword",
"username": "user1",
"user_arn": "arn:aws:elasticache:us-east-1:xxxxxxxxxx918:user:user1" //this is the bond between the secret and the user
}
```
## Lambda ローテーション関数
シークレットマネージャーの自動パスワードローテーションを有効にするには、[modify-user](https://docs.aws.amazon.com/cli/latest/reference/elasticache/modify-user.html) API を操作してユーザーのパスワードを更新する Lambda 関数を作成します。
この仕組みについては、「[ローテーションの仕組み](https://docs.aws.amazon.com/secretsmanager/latest/userguide/rotating-secrets.html#rotate-secrets_how)」を参照してください。
**注記**
一部のAWSサービスでは、混乱した代理シナリオを避けるために、AWSは `aws:SourceArn`および `aws:SourceAccount` グローバル条件キーの両方を使用することをお勧めします。ただし、ローテーション関数のポリシーに `aws:SourceArn` の条件を含めると、その ARN で指定されたシークレットだけをローテーションさせるためにローテーション関数を使用することができます。コンテキストキーのみを含めることをお勧めします`aws:SourceAccount`複数のシークレットに対して回転関数を使用できるようにする。
発生する可能性のある問題については、[AWS「Secrets Manager ローテーションのトラブルシューティング](https://docs.aws.amazon.com/secretsmanager/latest/userguide/troubleshoot_rotation.html)」を参照してください。
## ElastiCache ユーザーを作成してシークレットマネージャーに関連付ける方法
以下の手順は、ユーザーを作成してシークレットマネージャーに関連付ける方法を示しています。
1. **非アクティブユーザーの作成**
Linux、macOS、Unix の場合:
```
aws elasticache create-user \
--user-id user1 \
--user-name user1 \
--engine "REDIS" \
--no-password \ // no authentication is required
--access-string "*off* +get ~keys*" // this disables the user
```
Windows の場合:
```
aws elasticache create-user ^
--user-id user1 ^
--user-name user1 ^
--engine "REDIS" ^
--no-password ^ // no authentication is required
--access-string "*off* +get ~keys*" // this disables the user
```
次のようなレスポンスが表示されます。
```
{
"UserId": "user1",
"UserName": "user1",
"Status": "active",
"Engine": "redis",
"AccessString": "off ~keys* -@all +get",
"UserGroupIds": [],
"Authentication": {
"Type": "no_password"
},
"ARN": "arn:aws:elasticache:us-east-1:xxxxxxxxxx918:user:user1"
}
```
1. **シークレットを作成する**
Linux、macOS、Unix の場合:
```
aws secretsmanager create-secret \
--name production/ec/user1 \
--secret-string \
'{
"user_arn": "arn:aws:elasticache:us-east-1:123456xxxx:user:user1",
"username":"user1"
}'
```
Windows の場合:
```
aws secretsmanager create-secret ^
--name production/ec/user1 ^
--secret-string ^
'{
"user_arn": "arn:aws:elasticache:us-east-1:123456xxxx:user:user1",
"username":"user1"
}'
```
次のようなレスポンスが表示されます。
```
{
"ARN": "arn:aws:secretsmanager:us-east-1:123456xxxx:secret:production/ec/user1-eaFois",
"Name": "production/ec/user1",
"VersionId": "aae5b963-1e6b-4250-91c6-ebd6c47d0d95"
}
```
1. **パスワードをローテーションするように Lambda 関数を設定する**
1. にサインインAWS マネジメントコンソールし、[https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/elasticache/) で Lambda コンソールを開きます。
1. ナビゲーションパネルで **[Functions]** (関数) を選択し、作成した関数を選択します。関数名の左側のチェックボックスではなく、関数名を選択します。
1. **[設定]** タブを選択します。
1. **[General configuration]** (一般設定) で、**[Edit]** (編集) を選択し、**[Timeout]** (タイムアウト) を 12 分以上に設定します。
1. **[保存]** を選択します。
1. **[Environment variables]** (環境変数) を選択し、以下を設定します。
1. SECRETS\$1MANAGER\$1ENDPOINT – https://secretsmanager.**REGION**.amazonaws.com
1. SECRET\$1ARN – ステップ 2 で作成したシークレットの Amazon リソースネーム (ARN)。
1. USER\$1NAME – ElastiCache ユーザーのユーザー名、
1. **[保存]** を選択します。
1. **[Permissions]** (許可) を選択します。
1. **[Execution role]** (実行ロール) で、IAM コンソールに表示する Lambda 関数ロールの名前を選択します。
1. Lambda 関数でユーザーを変更してパスワードを設定するには、次のアクセス許可が必要です。
ElastiCache
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"elasticache:DescribeUsers",
"elasticache:ModifyUser"
],
"Resource": "arn:aws:elasticache:us-east-1:123456789012:user:user1"
}
]
}
```
------
Secrets Manager
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"secretsmanager:GetSecretValue",
"secretsmanager:DescribeSecret",
"secretsmanager:PutSecretValue",
"secretsmanager:UpdateSecretVersionStage"
],
"Resource": "arn:aws:secretsmanager:us-east-1:123456789012:secret:XXXX"
},
{
"Effect": "Allow",
"Action": "secretsmanager:GetRandomPassword",
"Resource": "*"
}
]
}
```
------
1. シークレットマネージャーのシークレットローテーションを設定する
1. **の使用についてはAWS マネジメントコンソール、[「コンソールを使用したAWS Secrets Manager シークレットの自動ローテーションの設定」を参照してください。](https://docs.aws.amazon.com/secretsmanager/latest/userguide/rotate-secrets_turn-on-for-other.html)**
ローテーションのスケジュール設定の詳細については、「[シークレットマネージャーのローテーションでのスケジュール式](https://docs.aws.amazon.com/secretsmanager/latest/userguide/rotate-secrets_schedule.html)」を参照してください。
1. **の使用についてはAWS CLI、[「AWS Secrets Managerを使用するための自動ローテーションの設定」を参照してください。AWS Command Line Interface](https://docs.aws.amazon.com/secretsmanager/latest/userguide/rotate-secrets-cli.html)**
# IAM を使用した認証
**Topics**
+ [概要:](#auth-iam-overview)
+ [制限事項](#auth-iam-limits)
+ [セットアップ](#auth-iam-setup)
+ [接続中](#auth-iam-Connecting)
## 概要:
IAM 認証では、キャッシュが Valkey または Redis OSS バージョン 7 以降を使用するように設定されている場合、IAM ID AWSを使用して ElastiCache for Valkey または Redis OSS への接続を認証できます。これにより、セキュリティモデルを強化し、多くの管理セキュリティタスクを簡素化できます。また、IAM 認証を使用すると、個々の ElastiCache キャッシュと ElastiCache ユーザーごとにきめ細かいアクセス制御を設定し、最小特権の権限の原則に従うことができます。ElastiCache の IAM 認証は、Valkey または Redis OSS の `AUTH` または `HELLO` コマンドで、有効期間の長い ElastiCache ユーザーパスワードの代わりに、有効期間の短い IAM 認証トークンを提供することによって機能します。IAM 認証トークンの詳細については、AWS全般のリファレンスガイドの署名[バージョン 4 の署名プロセス](https://docs.aws.amazon.com//general/latest/gr/signature-version-4.html)と、以下のコード例を参照してください。
IAM ID とそれに関連するポリシーを使用して、Valkey または Redis OSS アクセスをさらに制限できます。また、フェデレーテッドアイデンティティプロバイダーのユーザーに Valkey または Redis OSS キャッシュへのアクセス権を直接付与することもできます。
ElastiCache でAWS IAM を使用するには、まず認証モードを IAM に設定して ElastiCache ユーザーを作成する必要があります。その後、IAM ID を作成または再利用できます。IAM アイデンティティには、ElastiCache キャッシュと ElastiCache ユーザーに `elasticache:Connect` アクションを許可するための関連ポリシーが必要です。設定したら、IAM ユーザーまたはロールのAWS認証情報を使用して IAM 認証トークンを作成できます。最後に、キャッシュに接続するときに、有効期間が短い IAM 認証トークンを Valkey または Redis OSS クライアントのパスワードとして指定する必要があります。認証情報プロバイダーをサポートしている Valkey または Redis クライアントは、新しい接続ごとに一時的な認証情報を自動的に生成できます。ElastiCache は、IAM が有効な ElastiCache ユーザーの接続リクエストに対して IAM 認証を実行し、その接続リクエストを IAM で検証します。
## 制限事項
IAM 認証を使用する場合、以下の制限が適用されます。
+ Valkey 7.2 以降または Redis OSS バージョン 7.0 以降に対応した ElastiCache を使用している場合、IAM 認証が利用可能です。
+ IAM が有効な ElastiCache ユーザーの場合、ユーザー名とユーザー ID のプロパティは同じである必要があります。
+ IAM 認証トークンは 15 分間有効です。長時間接続する場合は、認証情報プロバイダーインターフェイスをサポートする Valkey または Redis OSS クライアントを使用することをお勧めします。
+ Valkey または Redis OSS に対応した ElastiCache への IAM 認証済み接続は、12 時間後に自動的に切断されます。新しい IAM 認証トークンを使用して`AUTH` または `HELLO` コマンドを送信することで、接続を 12 時間延長できます。
+ IAM 認証は `MULTI EXEC` コマンドではサポートされていません。
+ 現在、IAM 認証は以下のグローバル条件コンテキストキーをサポートしています。
+ サーバーレスキャッシュで IAM 認証を使用する場合、`aws:VpcSourceIp`、`aws:SourceVpc`、`aws:SourceVpce`、`aws:CurrentTime`、`aws:EpochTime`、`aws:ResourceTag/%s` (関連するサーバーレスキャッシュとユーザーから) がサポートされます。
+ レプリケーショングループで IAM 認証を使用する場合、`aws:SourceIp` および `aws:ResourceTag/%s` (関連するレプリケーショングループとユーザーから) がサポートされます。
グローバル条件コンテキストキーの詳細については、「IAM ユーザーガイド」の「[AWSグローバル条件コンテキストキー](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html)」を参照してください。
## セットアップ
IAM 認証をセットアップするには:
1. キャッシュを作成します。
```
aws elasticache create-serverless-cache \
--serverless-cache-name cache-01 \
--description "ElastiCache IAM auth application" \
--engine redis
```
1. アカウントが新しいロールを引き継ぐことを許可するロール用の IAM 信頼ポリシードキュメントを以下に示すように作成します。ポリシーを *trust-policy.json* というファイルに保存します。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": {
"Effect": "Allow",
"Principal": { "AWS": "arn:aws:iam::123456789012:root" },
"Action": "sts:AssumeRole"
}
}
```
------
1. 以下に示すように、IAM ポリシードキュメントを作成します。ポリシーを *policy.json* というファイルに保存します。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect" : "Allow",
"Action" : [
"elasticache:Connect"
],
"Resource" : [
"arn:aws:elasticache:us-east-1:123456789012:serverlesscache:cache-01",
"arn:aws:elasticache:us-east-1:123456789012:user:iam-user-01"
]
}
]
}
```
------
1. IAM ロールを作成します。
```
aws iam create-role \
--role-name "elasticache-iam-auth-app" \
--assume-role-policy-document file://trust-policy.json
```
1. IAM ポリシーを作成します。
```
aws iam create-policy \
--policy-name "elasticache-allow-all" \
--policy-document file://policy.json
```
1. IAM ポリシーをロールにアタッチします。
```
aws iam attach-role-policy \
--role-name "elasticache-iam-auth-app" \
--policy-arn "arn:aws:iam::123456789012:policy/elasticache-allow-all"
```
1. IAM を有効にしている新しいユーザーを作成します。
```
aws elasticache create-user \
--user-name iam-user-01 \
--user-id iam-user-01 \
--authentication-mode Type=iam \
--engine redis \
--access-string "on ~* +@all"
```
1. ユーザーグループを作成し、ユーザーをアタッチします。
```
aws elasticache create-user-group \
--user-group-id iam-user-group-01 \
--engine redis \
--user-ids default iam-user-01
aws elasticache modify-serverless-cache \
--serverless-cache-name cache-01 \
--user-group-id iam-user-group-01
```
## 接続中
**トークンをパスワードとして接続**
最初に、[AWS SigV4 の署名済みリクエスト](https://docs.aws.amazon.com//general/latest/gr/sigv4-signed-request-examples.html)を使用して、有効期間が短い IAM 認証トークンを生成する必要があります。その後、以下の例に示すように、Valkey または Redis OSS キャッシュに接続するときに IAM 認証トークンをパスワードとして指定します。
```
String userId = "insert user id";
String cacheName = "insert cache name";
boolean isServerless = true;
String region = "insert region";
// Create a default AWS Credentials provider.
// This will look for AWS credentials defined in environment variables or system properties.
AWSCredentialsProvider awsCredentialsProvider = new DefaultAWSCredentialsProviderChain();
// Create an IAM authentication token request and signed it using the AWS credentials.
// The pre-signed request URL is used as an IAM authentication token for ElastiCache with Redis OSS.
IAMAuthTokenRequest iamAuthTokenRequest = new IAMAuthTokenRequest(userId, cacheName, region, isServerless);
String iamAuthToken = iamAuthTokenRequest.toSignedRequestUri(awsCredentialsProvider.getCredentials());
// Construct Redis OSS URL with IAM Auth credentials provider
RedisURI redisURI = RedisURI.builder()
.withHost(host)
.withPort(port)
.withSsl(ssl)
.withAuthentication(userId, iamAuthToken)
.build();
// Create a new Lettuce Redis OSS client
RedisClient client = RedisClient.create(redisURI);
client.connect();
```
以下は `IAMAuthTokenRequest` の定義です。
```
public class IAMAuthTokenRequest {
private static final HttpMethodName REQUEST_METHOD = HttpMethodName.GET;
private static final String REQUEST_PROTOCOL = "http://";
private static final String PARAM_ACTION = "Action";
private static final String PARAM_USER = "User";
private static final String PARAM_RESOURCE_TYPE = "ResourceType";
private static final String RESOURCE_TYPE_SERVERLESS_CACHE = "ServerlessCache";
private static final String ACTION_NAME = "connect";
private static final String SERVICE_NAME = "elasticache";
private static final long TOKEN_EXPIRY_SECONDS = 900;
private final String userId;
private final String cacheName;
private final String region;
private final boolean isServerless;
public IAMAuthTokenRequest(String userId, String cacheName, String region, boolean isServerless) {
this.userId = userId;
this.cacheName = cacheName;
this.region = region;
this.isServerless = isServerless;
}
public String toSignedRequestUri(AWSCredentials credentials) throws URISyntaxException {
Request request = getSignableRequest();
sign(request, credentials);
return new URIBuilder(request.getEndpoint())
.addParameters(toNamedValuePair(request.getParameters()))
.build()
.toString()
.replace(REQUEST_PROTOCOL, "");
}
private Request getSignableRequest() {
Request request = new DefaultRequest<>(SERVICE_NAME);
request.setHttpMethod(REQUEST_METHOD);
request.setEndpoint(getRequestUri());
request.addParameters(PARAM_ACTION, Collections.singletonList(ACTION_NAME));
request.addParameters(PARAM_USER, Collections.singletonList(userId));
if (isServerless) {
request.addParameters(PARAM_RESOURCE_TYPE, Collections.singletonList(RESOURCE_TYPE_SERVERLESS_CACHE));
}
return request;
}
private URI getRequestUri() {
return URI.create(String.format("%s%s/", REQUEST_PROTOCOL, cacheName));
}
private void sign(SignableRequest request, AWSCredentials credentials) {
AWS4Signer signer = new AWS4Signer();
signer.setRegionName(region);
signer.setServiceName(SERVICE_NAME);
DateTime dateTime = DateTime.now();
dateTime = dateTime.plus(Duration.standardSeconds(TOKEN_EXPIRY_SECONDS));
signer.presignRequest(request, credentials, dateTime.toDate());
}
private static List toNamedValuePair(Map> in) {
return in.entrySet().stream()
.map(e -> new BasicNameValuePair(e.getKey(), e.getValue().get(0)))
.collect(Collectors.toList());
}
}
```
**認証情報プロバイダーに接続**
以下のコードは、IAM 認証情報プロバイダーを使用して ElastiCache で認証する方法を示しています。
```
String userId = "insert user id";
String cacheName = "insert cache name";
boolean isServerless = true;
String region = "insert region";
// Create a default AWS Credentials provider.
// This will look for AWS credentials defined in environment variables or system properties.
AWSCredentialsProvider awsCredentialsProvider = new DefaultAWSCredentialsProviderChain();
// Create an IAM authentication token request. Once this request is signed it can be used as an
// IAM authentication token for ElastiCache with Redis OSS.
IAMAuthTokenRequest iamAuthTokenRequest = new IAMAuthTokenRequest(userId, cacheName, region, isServerless);
// Create a Redis OSS credentials provider using IAM credentials.
RedisCredentialsProvider redisCredentialsProvider = new RedisIAMAuthCredentialsProvider(
userId, iamAuthTokenRequest, awsCredentialsProvider);
// Construct Redis OSS URL with IAM Auth credentials provider
RedisURI redisURI = RedisURI.builder()
.withHost(host)
.withPort(port)
.withSsl(ssl)
.withAuthentication(redisCredentialsProvider)
.build();
// Create a new Lettuce Redis OSS client
RedisClient client = RedisClient.create(redisURI);
client.connect();
```
以下は、IAMAuthTokenRequest を認証情報プロバイダーでラップして、必要に応じて一時的な認証情報を自動生成する Lettuce Redis クライアントの例です。
```
public class RedisIAMAuthCredentialsProvider implements RedisCredentialsProvider {
private static final long TOKEN_EXPIRY_SECONDS = 900;
private final AWSCredentialsProvider awsCredentialsProvider;
private final String userId;
private final IAMAuthTokenRequest iamAuthTokenRequest;
private final Supplier iamAuthTokenSupplier;
public RedisIAMAuthCredentialsProvider(String userId,
IAMAuthTokenRequest iamAuthTokenRequest,
AWSCredentialsProvider awsCredentialsProvider) {
this.userName = userName;
this.awsCredentialsProvider = awsCredentialsProvider;
this.iamAuthTokenRequest = iamAuthTokenRequest;
this.iamAuthTokenSupplier = Suppliers.memoizeWithExpiration(this::getIamAuthToken, TOKEN_EXPIRY_SECONDS, TimeUnit.SECONDS);
}
@Override
public Mono resolveCredentials() {
return Mono.just(RedisCredentials.just(userId, iamAuthTokenSupplier.get()));
}
private String getIamAuthToken() {
return iamAuthTokenRequest.toSignedRequestUri(awsCredentialsProvider.getCredentials());
}
}
```