翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。
# Amazon ElastiCache のデータセキュリティ
データを安全に保つために、Amazon ElastiCache および Amazon EC2 は、サーバーのデータへの不正アクセスに対する防御メカニズムを提供します。
Amazon ElastiCache for Memcached は、Memcached バージョン 1.6.12 以降を実行しているキャッシュ上のデータに対するオプションの暗号化機能を備えています。
Valkey および Redis OSS 対応の Amazon ElastiCache は、Valkey 7.2 以降、Redis OSS バージョン 3.2.6 (EOL の予定、「[Redis OSS バージョンのサポート終了スケジュール](engine-versions.md#deprecated-engine-versions)」を参照)、4.0.10 以降を実行しているキャッシュ上のデータに対するオプションの暗号化機能を提供します。Amazon ElastiCache では、IAM または Valkey および Redis OSS の AUTH のいずれかによるユーザーの認証と、ロールベースのアクセスコントロール (RBAC) を使用したユーザーオペレーションの承認もサポートします。
+ 転送時の暗号化では、ある場所から別の場所に移動するデータ (クラスターのノード間、キャッシュとアプリケーション間など) に対して暗号化が行なわれます。
+ 保管時の暗号化では、同期やバックアップオペレーションの実行中にオンディスクデータが暗号化されます。
ElastiCache では、IAM と Valkey および Redis OSS AUTH コマンドを使用したユーザーの認証と、ロールベースのアクセスコントロール (RBAC) を使用したユーザーオペレーションの承認をサポートします。
![\[イメージ: Valkey と Redis OSS に対応した ElastiCache のセキュリティの図\]](http://docs.aws.amazon.com/ja_jp/AmazonElastiCache/latest/dg/images/ElastiCache-Redis-Secure-Compliant.png)
*Valkey と Redis OSS に対応した ElastiCache のセキュリティの図*
**Topics**
+ [ElastiCache の転送時の暗号化 (TLS)](in-transit-encryption.md)
+ [ElastiCache での保管時の暗号化](at-rest-encryption.md)
+ [認証と認可](auth-redis.md)
# ElastiCache の転送時の暗号化 (TLS)
データを安全に保つために、Amazon ElastiCache および Amazon EC2 は、サーバーのデータへの不正アクセスに対する防御メカニズムを提供します。ElastiCache では転送時の暗号化機能を提供されるため、ある場所から別の場所に移動しているデータの保護ツールとして使用できます。
すべての Valkey または Redis OSS サーバーレスキャッシュで、転送時の暗号化が有効になっています。ノードベースのクラスターの場合、送信中の暗号化は、レプリケーショングループの作成時にレプリケーショングループ上でパラメータ `TransitEncryptionEnabled` を `true` (CLI: `--transit-encryption-enabled`) に設定することで有効にできます。これは、、AWS マネジメントコンソール、AWS CLIまたは ElastiCache API を使用してレプリケーショングループを作成する場合でも実行できます。
すべてのサーバーレスキャッシュで、転送時の暗号化が有効になっています。ノードベースのクラスターの場合、`CreateCacheCluster` (CLI: `create-cache-cluster`) オペレーションを使用してクラスターを作成するときに、パラメータ `TransitEncryptionEnabled` を `true` に設定する (CLI: `--transit-encryption-enabled`) ことで、クラスター上で送信中の暗号化を有効にできます。
**Topics**
+ [転送時の暗号化の概要](#in-transit-encryption-overview)
+ [転送中の暗号化の条件 (Valkey および Redis OSS)](#in-transit-encryption-constraints)
+ [転送時の暗号化の条件 (Memcached)](#in-transit-encryption-constraints)
+ [転送時の暗号化のベストプラクティス](#in-transit-encryption-best-practices)
+ [その他の Valkey および Redis OSS オプション](#in-transit-encryption-see-also)
+ [Memcached で転送時の暗号化を有効にする](#in-transit-encryption-enable-existing-mc)
+ [転送時の暗号化を有効にする](in-transit-encryption-enable.md)
+ [valkey-cli を使用した送信中の暗号化による ElastiCache (Valkey) または Amazon ElastiCache for Redis OSS への接続](connect-tls.md)
+ [Python を使用してノードベースの Redis OSS クラスターで送信中の暗号化を有効にする](in-transit-encryption-enable-python.md)
+ [転送時の暗号化を有効にする際のベストプラクティス](enable-python-best-practices.md)
+ [Openssl を使用して、転送時の暗号化が有効なノードに接続する (Memcached)](#in-transit-encryption-connect-mc)
+ [Java を使用して TLS Memcached クライアントを作成する](#in-transit-encryption-connect-java)
+ [PHP を使用して TLS Memcached クライアントを作成する](#in-transit-encryption-connect-php-mc)
## 転送時の暗号化の概要
Amazon ElastiCache の転送時の暗号化は、データが最も脆弱にポイント、つまりデータがある場所から別の場所に移動する際のデータのセキュリティを強化できるオプション機能です。エンドポイントでデータの暗号化と復号を行うにはある程度の処理が必要であるため、転送時の暗号化を有効にするとパフォーマンスに影響を及ぼす可能性があります。転送時の暗号化の使用時と未使用時でデータのベンチマークを取得して、ユースケースにおけるパフォーマンス影響を判断する必要があります。
ElastiCache 転送時の暗号化では、次の機能が実装されます。
+ **暗号化されたクライアント接続** — キャッシュノードへのクライアント接続は TLS で暗号化されます。
+ **暗号化されたサーバー接続 —** クラスター内のノード間を移動するデータは暗号化されます。
+ **[サーバー認証]** — クライアントは、適切なサーバーに接続していることを認証できます。
+ **[クライアント認証]** — Valkey および Redis OSS の AUTH 機能を使用して、サーバーはクライアントを認証できます。
## 転送中の暗号化の条件 (Valkey および Redis OSS)
ノードベースのクラスターの実装を計画する際には、Amazon ElastiCache の送信中の暗号化に関する次の制約事項に留意する必要があります。
+ 転送時の暗号化は、Valkey 7.2 以降、Redis OSS バージョン 3.2.6、4.0.10 以降を実行するレプリケーショングループでサポートされます。
+ 既存のクラスターにおける転送中の暗号化設定の変更は、Valkey 7.2 以降、Redis OSS バージョン 7 以降を実行しているレプリケーショングループでサポートされています。
+ 転送時の暗号化は、Amazon VPC. で実行しているレプリケーショングループでのみサポートされます。
+ 転送時の暗号化は、M1、M2 のノードタイプを実行しているレプリケーショングループではサポートされていません 。
詳細については、「[サポートされているノードの種類](CacheNodes.SupportedTypes.md)」を参照してください。
+ 転送時の暗号化は、パラメータ `TransitEncryptionEnabled` を `true` に明示的に設定することで有効化されます。
+ キャッシュクライアントが TLS 接続をサポートしていることと、クライアント設定で TLS 接続を有効にしていることを確認します。
+ 2026 年 1 月 26 日より、AWSは、ElastiCache for Valkey バージョン 7.2 以降および ElastiCache for Redis OSS バージョン 6 以降でサポートされる TLS の最小バージョンを 1.2 に更新します。お客様は、その日までにクライアントソフトウェアを更新する必要があります。この更新により、セキュリティ、コンプライアンス、規制上のニーズを満たすことができます。
## 転送時の暗号化の条件 (Memcached)
ノードベースのクラスターの実装を計画する際には、Amazon ElastiCache の送信中の暗号化に関する次の制約事項に留意する必要があります。
+ 転送時の暗号化は、Memcached バージョン 1.6.12 以降を実行するクラスターでサポートされます。
+ 転送時の暗号化は、Transport Layer Security (TLS) バージョン 1.2 および 1.3 をサポートします。
+ 転送時の暗号化は、Amazon VPC で実行しているクラスターでのみサポートされます。
+ 転送時の暗号化は、M1、M2、M3、R3、T2 のノードタイプを実行しているレプリケーショングループではサポートされていません。
詳細については、「[サポートされているノードの種類](CacheNodes.SupportedTypes.md)」を参照してください。
+ 転送時の暗号化は、パラメータ `TransitEncryptionEnabled` を `true` に明示的に設定することで有効化されます。
+ 転送時の暗号化は、クラスターの作成時にのみクラスターで有効にできます。クラスターを変更して転送時の暗号化のオンとオフを切り替えることはできません。
+ キャッシュクライアントが TLS 接続をサポートしていることと、クライアント設定で TLS 接続を有効にしていることを確認します。
## 転送時の暗号化のベストプラクティス
+ エンドポイントでデータの暗号化と復号を行うにはある程度の処理が必要であるため、転送時の暗号化の実装によりパフォーマンスが低下する可能性があります。自身のデータで転送時の暗号化使用時のベンチマークを暗号化なしの場合と比較して、実装におけるパフォーマンスの影響を判断してください。
+ 新しい接続の作成には高い負荷がかかる場合があるため、TLS 接続を持続させることで転送時の暗号化のパフォーマンスへの影響を軽減させることができます。
## その他の Valkey および Redis OSS オプション
Valkey および Redis OSS で使用できるオプションの詳細については、以下のリンクを参照してください。
+ [ElastiCache での保管時の暗号化](at-rest-encryption.md)
+ [Valkey および Redis OSS AUTH コマンドによる認証](auth.md)
+ [ロールベースのアクセスコントロール (RBAC)](Clusters.RBAC.md)
+ [Amazon VPC と ElastiCache のセキュリティ](VPCs.md)
+ [Amazon ElastiCache での Identity and Access Managementq](IAM.md)
## Memcached で転送時の暗号化を有効にする
AWSマネジメントコンソールを使用して Memcached クラスターの作成時に転送時の暗号化を有効にするには、以下のように選択します。
+ エンジンとして Memcached を選択します。
+ エンジンバージョン 1.6.12 以降。
+ **[Encryption in transit]** (転送時の暗号化) で、**[Enable]** (有効化) を選択します。
ステップバイステップの手順については、「[Valkey または Redis OSS 用のクラスターの作成](Clusters.Create.md)」を参照してください。
# 転送時の暗号化を有効にする
すべてのサーバーレスキャッシュで、転送時の暗号化が有効になっています。ノードベースのクラスターでは、、 CLI AWS マネジメントコンソール、または ElastiCache API AWSを使用して転送時の暗号化を有効にできます。
## を使用した転送時の暗号化の有効化AWS マネジメントコンソール
### を使用して新しいノードベースのクラスターの転送時の暗号化を有効にするAWS マネジメントコンソール
独自のクラスターを設計する場合、「簡単な作成」方式の「開発/テスト」構成と「本番稼働用」構成では、転送時の暗号化が有効になっています。設定を自分で選択するときは、以下のように選択します。
+ エンジンバージョン 3.2.6 または 4.0.10 以降。
+ **[転送中の暗号化]** オプションの **[有効化]** の横にあるチェックボックスをオンにします。
詳しいステップについては、以下を参照ください。
+ [Valkey (クラスターモードが無効) クラスターの作成 (コンソール)](SubnetGroups.designing-cluster-pre.valkey.md#Clusters.Create.CON.valkey-gs)
+ [Valkey または Redis OSS (クラスターモードが有効) クラスターの作成 (コンソール)](Clusters.Create.md#Clusters.Create.CON.RedisCluster)
### を使用して既存のノードベースのクラスターの転送時の暗号化を有効にするAWS マネジメントコンソール
転送中の暗号化を有効にするには、2 段階のプロセスが必要です。まず、転送中の暗号化モードを `preferred` に設定する必要があります。このモードでは、Valkey または Redis OSS クライアントは暗号化された接続と暗号化されていない接続の両方を使用して接続できます。暗号化接続を使用するようにすべての Valkey または Redis OSS クライアントを移行したら、クラスター設定を変更して転送中の暗号化モードを `required` に設定できます。転送中の暗号化モードを `required` に設定すると、暗号化されていない接続はすべてドロップされ、暗号化された接続のみが許可されます。
****[転送中の暗号化モード]** を **[優先]** に設定する**
1. にサインインAWS マネジメントコンソールし、[https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/) で Amazon ElastiCache コンソールを開きます。
1. 左側にあるナビゲーションペインに表示されている ElastiCache の **[リソース]** から **[Valkey キャッシュ]** または **[Redis OSS キャッシュ]** を選択します。
1. 更新するキャッシュを選択します。
1. **[アクション]** ドロップダウンを選択してから、**[変更]** を選択します。
1. **[Security]** (セキュリティ) セクションの **[Encryption in transit]** (転送時の暗号化) で **[Enable]** (有効化) を選択します。
1. **[Transit encryption mode]** (転送中の暗号化モード) として **[Preferred]** (優先) を選択します。
1. 変更を行ってから、**[Preview changes]** (変更のプレビュー) を選択します。
すべての Valkey または Redis OSS クライアントを暗号化接続を使用するよう移行した後で、以下を行います。
****[転送中の暗号化モード]** を **[必須]** に設定する**
1. にサインインAWS マネジメントコンソールし、[https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/) で Amazon ElastiCache コンソールを開きます。
1. 左側にあるナビゲーションペインに表示されている ElastiCache の **[リソース]** から **[Valkey キャッシュ]** または **[Redis OSS キャッシュ]** を選択します。
1. 更新するキャッシュを選択します。
1. **[Actions]** (アクション) ドロップダウンを選択してから、**[Modify]** (変更) を選択します。
1. **[Security]** (セキュリティ) セクションの **[Transit encryption mode]** (転送中の暗号化モード) として **[Required]** (必須) を選択します。
1. 変更を行ってから、**[変更のプレビュー]** を選択します。
## を使用した転送時の暗号化の有効化AWS CLI
AWS CLIを使用して Valkey または Redis OSS レプリケーショングループの作成時に転送時の暗号化を有効にするには、パラメータ `transit-encryption-enabled` を使用します。
### Valkey または Redis OSS の新しいノードベースのクラスター (クラスターモードが無効) 上で送信中の暗号化を有効にする (CLI)
AWS CLIオペレーション`create-replication-group`と次のパラメータを使用して、転送時の暗号化が有効になっているレプリカを持つ Valkey または Redis OSS レプリケーショングループを作成します。
**主要パラメータ:**
+ **--engine** — `valkey` または `redis` を指定する必要があります。
+ **--engine-version** — エンジンが Redis OSS の場合、3.2.6、4.0.10 以降である必要があります。
+ **--transit-encryption-enabled** — 必須 転送時の暗号化を有効にする場合、`--cache-subnet-group` パラメータの値も指定する必要があります。
+ **--num-cache-clusters** — 1 以上を指定する必要があります。このパラメータの最大値は 6 です。
詳細については次を参照してください:
+ [Valkey または Redis OSS (クラスターモードが無効) レプリケーショングループを最初から作成する (AWS CLI)](Replication.CreatingReplGroup.NoExistingCluster.Classic.md#Replication.CreatingReplGroup.NoExistingCluster.Classic.CLI)
+ [create-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html)
### Valkey または Redis OSS の新しいノードベースのクラスター (クラスターモードが有効) 上で送信中の暗号化を有効にする (CLI)
AWS CLIオペレーション`create-replication-group`と次のパラメータを使用して、転送時の暗号化が有効になっている Valkey または Redis OSS (クラスターモードが有効) レプリケーショングループを作成します。
**主要パラメータ:**
+ **--engine** — `valkey` または `redis` を指定する必要があります。
+ **--engine-version** — エンジンが Redis OSS の場合、3.2.6、4.0.10 以降である必要があります。
+ **--transit-encryption-enabled** — 必須。転送時の暗号化を有効にする場合、`--cache-subnet-group` パラメータの値も指定する必要があります。
+ 次のいずれかのパラメータセットを使用して、レプリケーショングループのノード グループの構成を指定します。
+ **--num-node-groups** — このレプリケーショングループ内のシャード数 (ノードグループ数) を指定します。このパラメータの最大値は 500 です。
**--replicas-per-node-group** — 各ノードグループ (シャード) のレプリカノードの数を指定します。ここで指定される値は、このレプリケーショングループのすべてのシャードに適用されます。このパラメータの最大値は 5 です。
+ **--node-group-configuration** — 各シャードの構成を個別に指定します。
詳細については次を参照してください:
+ [Valkey または Redis OSS (クラスターモードが有効) レプリケーショングループを最初から作成する (AWS CLI)](Replication.CreatingReplGroup.NoExistingCluster.Cluster.md#Replication.CreatingReplGroup.NoExistingCluster.Cluster.CLI)
+ [create-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html)
### AWS CLIを使用して既存のクラスターで転送時の暗号化を有効にする
転送中の暗号化を有効にするには、2 段階のプロセスが必要です。まず、転送中の暗号化モードを `preferred` に設定する必要があります。このモードでは、Valkey または Redis OSS クライアントは暗号化された接続と暗号化されていない接続の両方を使用して接続できます。暗号化接続を使用するようにすべての Valkey または Redis OSS クライアントを移行したら、クラスター設定を変更して転送中の暗号化モードを `required` に設定できます。転送中の暗号化モードを `required` に設定すると、暗号化されていない接続はすべてドロップされ、暗号化された接続のみが許可されます。
AWS CLIオペレーション`modify-replication-group`と次のパラメータを使用して、転送時の暗号化が無効になっている Valkey または Redis OSS (クラスターモードが有効) レプリケーショングループを更新します。
**転送中の暗号化を有効にするには**
1. 次のパラメータを使用して、転送暗号化モードを `preferred` に設定する
+ **--transit-encryption-enabled** — 必須
+ **--transit-encryption-mode** — `preferred` に設定する必要があります。
1. 次のパラメータを使用して、転送暗号化モードを `required` に設定します。
+ **--transit-encryption-enabled** — 必須
+ **--transit-encryption-mode** — `required` に設定する必要があります。
# valkey-cli を使用した送信中の暗号化による ElastiCache (Valkey) または Amazon ElastiCache for Redis OSS への接続
送信中の暗号化が有効な ElastiCache for Redis OSS キャッシュのデータにアクセスするには、Secure Socket Layer (SSL) に対応したクライアントを使用します。Amazon Linux や Amazon Linux 2 で、TLS/SSL を使用して valkey-cli を使用することもできます。クライアントが TLS に対応していない場合は、クライアントホストで `stunnel` コマンドを使用して、Redis OSS ノードへの SSL トンネルを作成できます。
## Linux との暗号化された接続
valkey-cli を使用して、Amazon Linux 2 または Amazon Linux で送信中の暗号化が有効になっている Valkey または Redis OSS のクラスターに接続するには、次のステップを実行します。
1. valkey-cli ユーティリティをダウンロードし、コンパイルします。このユーティリティは Valkey ソフトウェアディストリビューションに含まれています。
1. EC2 インスタンスのコマンドプロンプトで、使用している Linux のバージョンに適したコマンドを入力します。
**Amazon Linux 2**
Amazon Linux 2 を使用している場合は、次のように入力します。
```
sudo yum -y install openssl-devel gcc
wget https://github.com/valkey-io/valkey/archive/refs/tags/7.2.6.tar.gz
tar xvzf valkey-7.2.6.tar.gz
cd valkey-7.2.6
make distclean
make valkey-cli BUILD_TLS=yes
sudo install -m 755 src/valkey-cli /usr/local/bin/
```
**Amazon Linux**
Amazon Linux を使用している場合は、次のように入力します。
```
sudo yum install gcc jemalloc-devel openssl-devel tcl tcl-devel clang wget
wget https://github.com/valkey-io/valkey/archive/refs/tags/8.0.0.tar.gz
tar xvzf valkey-8.0.0.tar.gz
cd valkey-8.0.0
make valkey-cli CC=clang BUILD_TLS=yes
sudo install -m 755 src/valkey-cli /usr/local/bin/
```
Amazon Linux では、以下の追加ステップを実行する必要がある場合もあります。
```
sudo yum install clang
CC=clang make
sudo make install
```
1. valkey-cli ユーティリティをダウンロードしてインストールしたら、オプションの `make-test` コマンドを実行することをお勧めします。
1. 暗号化と認証が有効になっているクラスターに接続するには、次のコマンドを入力します。
```
valkey-cli -h Primary or Configuration Endpoint --tls -a 'your-password' -p 6379
```
**注記**
Amazon Linux 2023 に redis6 をインストールした場合、`valkey-cli` の代わりに `redis6-cli` コマンドを使用できるようになりました。
```
redis6-cli -h Primary or Configuration Endpoint --tls -p 6379
```
## stunnel による暗号化された接続
valkey-cli を使用して、stunnel を使用して転送時の暗号化を有効にした Redis OSS クラスターに接続するには、次の手順に従います。
1. SSH を使用してクライアントに接続し、`stunnel` をインストールします。
```
sudo yum install stunnel
```
1. 次のコマンドを実行して、ファイル `'/etc/stunnel/valkey-cli.conf'` の作成と編集を同時に行い、以下の出力をテンプレートとして使用して、ElastiCache for Redis OSS クラスターエンドポイントを 1 つ以上の接続パラメータに追加します。
```
vi /etc/stunnel/valkey-cli.conf
fips = no
setuid = root
setgid = root
pid = /var/run/stunnel.pid
debug = 7
delay = yes
options = NO_SSLv2
options = NO_SSLv3
[valkey-cli]
client = yes
accept = 127.0.0.1:6379
connect = primary.ssltest.wif01h.use1.cache.amazonaws.com:6379
[valkey-cli-replica]
client = yes
accept = 127.0.0.1:6380
connect = ssltest-02.ssltest.wif01h.use1.cache.amazonaws.com:6379
```
この例では、設定ファイルに `valkey-cli` と `valkey-cli-replica` という 2 つの接続があります。パラメータは次のように設定されます。
+ この stunnel インスタンスがクライアントであることを指定するために、**client** は yes に設定されています。
+ **accept** はクライアント IP に設定されています。この例では、プライマリはポート 6379 の Redis OSS のデフォルト 127.0.0.1 に設定されています。レプリカは別のポートを呼び出し、6380 に設定する必要があります。エフェメラルポート 1024～65535 を使用できます。詳細については、*Amazon VPC ユーザーガイド*の「[一時ポート](https://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_ACLs.html#VPC_ACLs_Ephemeral_Ports)」を参照してください。
+ **connect** は Redis OSS サーバーエンドポイントに設定されています。詳細については、「[ElastiCache での接続エンドポイントの検索](Endpoints.md)」を参照してください。
1. 起動します。`stunnel`
```
sudo stunnel /etc/stunnel/valkey-cli.conf
```
`netstat` コマンドを使用して、トンネルが開始されたことを確認します。
```
sudo netstat -tulnp | grep -i stunnel
tcp 0 0 127.0.0.1:6379 0.0.0.0:* LISTEN 3189/stunnel
tcp 0 0 127.0.0.1:6380 0.0.0.0:* LISTEN 3189/stunnel
```
1. トンネルのローカルエンドポイントを使用して、暗号化された Redis OSS ノードに接続します。
+ ElastiCache for Redis OSS クラスターの作成中に AUTH パスワードが使用されなかった場合、この例では valkey-cli を使用して、Amazon Linux で valkey-cli の完全パスを使用して ElastiCache for Redis OSS サーバーに接続します。
```
/home/ec2-user/redis-7.2.5/src/valkey-cli -h localhost -p 6379
```
Redis OSS クラスターの作成中に AUTH パスワードが使用された場合、この例では valkey-cli を使用して、Amazon Linux で valkey-cli の完全パスを使用して Redis OSS サーバーに接続します。
```
/home/ec2-user/redis-7.2.5/src/valkey-cli -h localhost -p 6379 -a my-secret-password
```
または
+ ディレクトリを redis-7.2.5 に変更し、次の操作を行います。
ElastiCache for Redis OSS クラスターの作成中に AUTH パスワードが使用されなかった場合、この例では valkey-cli を使用して、Amazon Linux で valkey-cli の完全パスを使用して ElastiCache for Redis OSS サーバーに接続します。
```
src/valkey-cli -h localhost -p 6379
```
Redis OSS クラスターの作成中に AUTH パスワードが使用された場合、この例では valkey-cli を使用して、Amazon Linux で valkey-cli の完全パスを使用して Valkey または Redis OSS サーバーに接続します。
```
src/valkey-cli -h localhost -p 6379 -a my-secret-password
```
この例では、Telnet を使用して Valkey または Redis OSS サーバーに接続します。
```
telnet localhost 6379
Trying 127.0.0.1...
Connected to localhost.
Escape character is '^]'.
auth MySecretPassword
+OK
get foo
$3
bar
```
1. SSL トンネルを停止して閉じるには、`pkill` stunnel プロセスを実行します。
```
sudo pkill stunnel
```
# Python を使用してノードベースの Redis OSS クラスターで送信中の暗号化を有効にする
以下のガイドでは、最初は転送中の暗号化を無効にして作成された Redis OSS 7.0 クラスターで転送中の暗号化を有効にする方法を説明します。TCP クライアントと TLS クライアントは、このプロセス中もダウンタイムなしでクラスターとの通信を継続します。
Boto3 は環境変数から必要な認証情報 (`aws_access_key_id`、`aws_secret_access_key`、および `aws_session_token`) を取得します。これらの認証情報は、このガイドに示されている Python コードを処理するために `python3` を実行するのと同じ bash ターミナルにあらかじめ貼り付けておきます。以下の例のコードは、同じ VPC で起動された EC2 インスタンスからのプロセスであり、その中に ElastiCache Redis OSS クラスターを作成するために使用されます。
**注記**
次の例では、ElastiCache 管理オペレーション (クラスターまたはユーザーの作成) で boto3 SDK を使用し、データ処理で redis-py/redis-py-cluster を使用します。
クラスター変更 API でオンライン TLS 移行を使用するには、boto3 バージョン (=\$1) 1.26.39 以上を使用する必要があります。
ElastiCache は、Valkey バージョン 7.2 以降、Redis OSS バージョン 7.0 以降のクラスターに対してのみオンライン TLS 移行をサポートします。そのため、7.0 より前のバージョンの Redis OSS を実行しているクラスターがある場合は、クラスターの Redis OSS バージョンをアップグレードする必要があります。バージョンの違いの詳細については、「[Redis OSS でのメジャーエンジンバージョンの動作と互換性の違い](VersionManagementConsiderations.md)」を参照してください。
**Topics**
+ [ElastiCache Valkey または Redis OSS クラスターを起動する文字列定数を定義する](#enable-python-define-constants)
+ [クラスター構成用のクラスを定義する](#enable-python-define-classes)
+ [クラスター自体を表すクラスを定義する](#enable-python-define-classes-cluster)
+ [(オプション) Valkey または Redis OSS クラスターへのクライアント接続をデモするためのラッパークラスを作成する](#enable-python-create-wrapper)
+ [転送中の暗号化設定を変更するプロセスをデモする main 関数を作成する](#enable-python-main-function)
## ElastiCache Valkey または Redis OSS クラスターを起動する文字列定数を定義する
まず、`security-group`、、 `Cache Subnet group`などの ElastiCache クラスターの作成に必要なAWSエンティティの名前を保持する単純な Python 文字列定数を定義しましょう`default parameter group`。これらのAWSエンティティはすべて、使用するリージョンのAWSアカウントで事前に作成する必要があります。
```
#Constants definitions
SECURITY_GROUP = "sg-0492aa0a29c558427"
CLUSTER_DESCRIPTION = "This cluster has been launched as part of the online TLS migration user guide"
EC_SUBNET_GROUP = "client-testing"
DEFAULT_PARAMETER_GROUP_REDIS_7_CLUSTER_MODE_ENABLED = "default.redis7.cluster.on"
```
## クラスター構成用のクラスを定義する
ここで、クラスターの設定を表すシンプルな Python クラスをいくつか定義しましょう。このクラスには、Valkey または Redis OSS のバージョン、インスタンスタイプ、転送中の暗号化 (TLS) が有効か無効かなど、クラスターに関するメタデータが格納されます。
```
#Class definitions
class Config:
def __init__(
self,
instance_type: str = "cache.t4g.small",
version: str = "7.0",
multi_az: bool = True,
TLS: bool = True,
name: str = None,
):
self.instance_type = instance_type
self.version = version
self.multi_az = multi_az
self.TLS = TLS
self.name = name or f"tls-test"
def create_base_launch_request(self):
return {
"ReplicationGroupId": self.name,
"TransitEncryptionEnabled": self.TLS,
"MultiAZEnabled": self.multi_az,
"CacheNodeType": self.instance_type,
"Engine": "redis",
"EngineVersion": self.version,
"CacheSubnetGroupName": EC_SUBNET_GROUP ,
"CacheParameterGroupName": DEFAULT_PARAMETER_GROUP_REDIS_7_CLUSTER_MODE_ENABLED ,
"ReplicationGroupDescription": CLUSTER_DESCRIPTION,
"SecurityGroupIds": [SECURITY_GROUP],
}
class ConfigCME(Config):
def __init__(
self,
instance_type: str = "cache.t4g.small",
version: str = "7.0",
multi_az: bool = True,
TLS: bool = True,
name: str = None,
num_shards: int = 2,
num_replicas_per_shard: int = 1,
):
super().__init__(instance_type, version, multi_az, TLS, name)
self.num_shards = num_shards
self.num_replicas_per_shard = num_replicas_per_shard
def create_launch_request(self) -> dict:
launch_request = self.create_base_launch_request()
launch_request["NumNodeGroups"] = self.num_shards
launch_request["ReplicasPerNodeGroup"] = self.num_replicas_per_shard
return launch_request
```
## クラスター自体を表すクラスを定義する
次に、ElastiCache Valkey または Redis OSS クラスター自体を表すシンプルな Python クラスをいくつか定義しましょう。このクラスには、クラスターの作成や ElastiCache API のクエリなどの ElastiCache 管理オペレーションに使用する boto3 クライアントを格納するクライアントフィールドがあります。
```
import botocore.config
import boto3
# Create boto3 client
def init_client(region: str = "us-east-1"):
config = botocore.config.Config(retries={"max_attempts": 10, "mode": "standard"})
init_request = dict()
init_request["config"] = config
init_request["service_name"] = "elasticache"
init_request["region_name"] = region
return boto3.client(**init_request)
class ElastiCacheClusterBase:
def __init__(self, name: str):
self.name = name
self.elasticache_client = init_client()
def get_first_replication_group(self):
return self.elasticache_client.describe_replication_groups(
ReplicationGroupId=self.name
)["ReplicationGroups"][0]
def get_status(self) -> str:
return self.get_first_replication_group()["Status"]
def get_transit_encryption_enabled(self) -> bool:
return self.get_first_replication_group()["TransitEncryptionEnabled"]
def is_available(self) -> bool:
return self.get_status() == "available"
def is_modifying(self) -> bool:
return self.get_status() == "modifying"
def wait_for_available(self):
while True:
if self.is_available():
break
else:
time.sleep(5)
def wait_for_modifying(self):
while True:
if self.is_modifying():
break
else:
time.sleep(5)
def delete_cluster(self) -> bool:
self.elasticache_client.delete_replication_group(
ReplicationGroupId=self.name, RetainPrimaryCluster=False
)
def modify_transit_encryption_mode(self, new_transit_encryption_mode: str):
# generate api call to migrate the cluster to TLS preffered or to TLS required
self.elasticache_client.modify_replication_group(
ReplicationGroupId=self.name,
TransitEncryptionMode=new_transit_encryption_mode,
TransitEncryptionEnabled=True,
ApplyImmediately=True,
)
self.wait_for_modifying()
class ElastiCacheClusterCME(ElastiCacheClusterBase):
def __init__(self, name: str):
super().__init__(name)
@classmethod
def launch(cls, config: ConfigCME = None) -> ElastiCacheClusterCME:
config = config or ConfigCME()
print(config)
new_cluster = ElastiCacheClusterCME(config.name)
launch_request = config.create_launch_request()
new_cluster.elasticache_client.create_replication_group(**launch_request)
new_cluster.wait_for_available()
return new_cluster
def get_configuration_endpoint(self) -> str:
return self.get_first_replication_group()["ConfigurationEndpoint"]["Address"]
#Since the code can throw exceptions, we define this class to make the code more readable and
#so we won't forget to delete the cluster
class ElastiCacheCMEManager:
def __init__(self, config: ConfigCME = None):
self.config = config or ConfigCME()
def __enter__(self) -> ElastiCacheClusterCME:
self.cluster = ElastiCacheClusterCME.launch(self.config)
return self.cluster
def __exit__(self, exc_type, exc_val, exc_tb):
self.cluster.delete_cluster()
```
## (オプション) Valkey または Redis OSS クラスターへのクライアント接続をデモするためのラッパークラスを作成する
次に、`redis-py-cluster` クライアント用のラッパークラスを作成しましょう。このラッパークラスは、クラスターにいくつかのキーをあらかじめ入力してから、ランダムに繰り返し `get` コマンドを実行することをサポートします。
**注記**
これはオプションのステップですが、後のステップに含まれる main 関数のコードが簡略化されます。
```
import redis
improt random
from time import perf_counter_ns, time
class DowntimeTestClient:
def __init__(self, client):
self.client = client
# num of keys prefilled
self.prefilled = 0
# percent of get above prefilled
self.percent_get_above_prefilled = 10 # nil result expected when get hit above prefilled
# total downtime in nano seconds
self.downtime_ns = 0
# num of success and fail operations
self.success_ops = 0
self.fail_ops = 0
self.connection_errors = 0
self.timeout_errors = 0
def replace_client(self, client):
self.client = client
def prefill_data(self, timelimit_sec=60):
end_time = time() + timelimit_sec
while time() < end_time:
self.client.set(self.prefilled, self.prefilled)
self.prefilled += 1
# unsuccesful operations throw exceptions
def _exec(self, func):
try:
start_ns = perf_counter_ns()
func()
self.success_ops += 1
elapsed_ms = (perf_counter_ns() - start_ns) // 10 ** 6
# upon succesful execution of func
# reset random_key to None so that the next command
# will use a new random key
self.random_key = None
except Exception as e:
elapsed_ns = perf_counter_ns() - start_ns
self.downtime_ns += elapsed_ns
# in case of failure- increment the relevant counters so that we will keep track
# of how many connection issues we had while trying to communicate with
# the cluster.
self.fail_ops += 1
if e.__class__ is redis.exceptions.ConnectionError:
self.connection_errors += 1
if e.__class__ is redis.exceptions.TimeoutError:
self.timeout_errors += 1
def _repeat_exec(self, func, seconds):
end_time = time() + seconds
while time() < end_time:
self._exec(func)
def _new_random_key_if_needed(self, percent_above_prefilled):
if self.random_key is None:
max = int((self.prefilled * (100 + percent_above_prefilled)) / 100)
return random.randint(0, max)
return self.random_key
def _random_get(self):
key = self._new_random_key_if_needed(self.percent_get_above_prefilled)
result = self.client.get(key)
# we know the key was set for sure only in the case key < self.prefilled
if key < self.prefilled:
assert result.decode("UTF-8") == str(key)
def repeat_get(self, seconds=60):
self._repeat_exec(self._random_get, seconds)
def get_downtime_ms(self) -> int:
return self.downtime_ns // 10 ** 6
def do_get_until(self, cond_check):
while not cond_check():
self.repeat_get()
# do one more get cycle once condition is met
self.repeat_get()
```
## 転送中の暗号化設定を変更するプロセスをデモする main 関数を作成する
それでは、次の処理を行う main 関数を定義しましょう。
1. boto3 ElastiCache クライアントを使用してクラスターを作成します。
1. TLS を使用しないクリア TCP 接続でクラスターに接続する `redis-py-cluster` クライアントを初期化します。
1. `redis-py-cluster` クライアントはクラスターにいくつかのデータを事前入力します。
1. boto3 クライアントは、TLS なしから TLS 優先への TLS 移行をトリガーします。
1. クラスターが TLS `Preferred` に移行されている間、`redis-py-cluster` TCP クライアントは、移行が完了するまでクラスターに繰り返し `get` オペレーションを送信します。
1. TLS `Preferred` への移行が完了したら、クラスターが転送中の暗号化をサポートしていることを確認します。その後、TLS を使用してクラスターに接続する `redis-py-cluster` クライアントを作成します。
1. 新しい TLS クライアントと古い TCP クライアントを使用して、いくつかの `get` コマンドを送信します。
1. boto3 クライアントは、TLS `Preferred` から TLS 必須への TLS 移行をトリガーします。
1. クラスターが TLS 必須に移行されている間、redis-py-cluster TCP クライアントは、移行が完了するまでクラスターに繰り返し `get` オペレーションを送信します。
```
import redis
def init_cluster_client(
cluster: ElastiCacheClusterCME, prefill_data: bool, TLS: bool = True) -> DowntimeTestClient:
# we must use for the host name the cluster configuration endpoint.
redis_client = redis.RedisCluster(
host=cluster.get_configuration_endpoint(), ssl=TLS, socket_timeout=0.25, socket_connect_timeout=0.1
)
test_client = DowntimeTestClient(redis_client)
if prefill_data:
test_client.prefill_data()
return test_client
if __name__ == '__main__':
config = ConfigCME(TLS=False, instance_type="cache.m5.large")
with ElastiCacheCMEManager(config) as cluster:
# create a client that will connect to the cluster with clear tcp connection
test_client_tcp = init_cluster_client(cluster, prefill_data=True, TLS=False)
# migrate the cluster to TLS Preferred
cluster.modify_transit_encryption_mode(new_transit_encryption_mode="preferred")
# do repeated get commands until the cluster finishes the migration to TLS Preferred
test_client_tcp.do_get_until(cluster.is_available)
# verify that in transit encryption is enabled so that clients will be able to connect to the cluster with TLS
assert cluster.get_transit_encryption_enabled() == True
# create a client that will connect to the cluster with TLS connection.
# we must first make sure that the cluster indeed supports TLS
test_client_tls = init_cluster_client(cluster, prefill_data=True, TLS=True)
# by doing get commands with the tcp client for 60 more seconds
# we can verify that the existing tcp connection to the cluster still works
test_client_tcp.repeat_get(seconds=60)
# do get commands with the new TLS client for 60 more seconds
test_client_tcp.repeat_get(seconds=60)
# migrate the cluster to TLS required
cluster.modify_transit_encryption_mode(new_transit_encryption_mode="required")
# from this point the tcp clients will be disconnected and we must not use them anymore.
# do get commands with the TLS client until the cluster finishes migartion to TLS required mode.
test_client_tls.do_get_until(cluster.is_available)
```
# 転送時の暗号化を有効にする際のベストプラクティス
## 転送中の暗号化を有効にする前: DNS レコードが適切に処理されていることを確認
**注記**
このプロセス中に、古いエンドポイントを変更および削除します。エンドポイントの使い方を誤ると、Valkey または Redis OSS クライアントが古くて削除されたエンドポイントを使用し、クラスターに接続できなくなる可能性があります。
クラスターが TLS なしから TLS 優先へ移行される間、古いクラスター設定エンドポイントの DNS レコードは保持され、新しいクラスター設定エンドポイントの DNS レコードは別のフォーマットで生成されます。TLS が有効なクラスターは、TLS が無効のクラスターとは異なる形式の DNS レコードを使用します。クラスターが `encryption mode: Preferred` に設定されている場合、ElastiCache は両方の DNS レコードを保持するため、アプリケーションおよび他の Valkey または Redis OSS のクライアントは、レコード間で切り替えることができます。TLS 移行プロセス中に、DNS レコードの次の変更が行われます。
### 転送中の暗号化を有効にした場合に行われる DNS レコードの変更の説明
**CME クラスターの場合**
クラスターが [転送暗号化モード: 優先] に設定されている場合:
+ TLS なしクラスター用の元のクラスター設定エンドポイントはアクティブな状態を維持します。クラスターを TLS 暗号化モード [なし] から [優先] に再設定しても、ダウンタイムは発生しません。
+ クラスターが TLS 優先モードに設定されると、新しい TLS Valkey または Redis OSS エンドポイントが生成されます。これらの新しいエンドポイントは、古いエンドポイントと同じ IP (TLS なし) に解決されます。
+ 新しい TLS Valkey または Redis OSS 設定エンドポイントは ElastiCache コンソールと `describe-replication-group` API へのレスポンスで公開されます。
クラスターが [転送暗号化モード: 必須] に設定されている場合:
+ TLS が有効になっていない古いエンドポイントは削除されます。TLS クラスターエンドポイントのダウンタイムは発生しません。
+ 新しい `cluster-configuration-endpoint` は、ElastiCache コンソールまたは `describe-replication-group` API から取得できます。
**自動フェイルオーバーが有効または自動フェイルオーバーが無効な CMD クラスターの場合**
レプリケーショングループが [転送暗号化モード: 優先] に設定されている場合:
+ TLS が有効になっていないクラスターの元のプライマリエンドポイントとリーダーエンドポイントはアクティブなままです。
+ クラスターが TLS `Preferred` モードに設定されると、新しいプライマリエンドポイントとリーダーエンドポイントが生成されます。この新しいエンドポイントは、古いエンドポイントと同じ IP (TLS なし) に解決されます。
+ 新しいプライマリエンドポイントとリーダーエンドポイントは ElastiCache コンソールと `describe-replication-group` API へのレスポンスで公開されます。
レプリケーショングループが [転送暗号化モード: 必須] に設定されている場合:
+ 古い TLS なしのプライマリエンドポイントとリーダーエンドポイントは削除されます。TLS クラスターエンドポイントのダウンタイムは発生しません。
+ 新しいプライマリエンドポイントとリーダーエンドポイントは、ElastiCache コンソールまたは `describe-replication-group` API から取得できます。
### DNS レコードの推奨される使用方法
**CME クラスターの場合**
+ アプリケーションのコードでは、ノードごとの DNS レコードの代わりにクラスター設定エンドポイントを使用してください。ノードごとの DNS 名を直接使用することはお勧めしません。移行中に DNS 名は変更され、アプリケーションコードによってクラスターへの接続が切断されるためです。
+ クラスター設定エンドポイントはこのプロセス中に変更されるため、アプリケーションでハードコードしないでください。
+ クラスター設定エンドポイントはこのプロセス中に変更される可能性があるため、アプリケーションでハードコードすることはお勧めしません。送信中の暗号化が完了したら、`describe-replication-group` API (上記太字で表記) を使用してクラスター設定エンドポイントのクエリを実行し、応答として取得した DNS をこの時点から使用します。
**自動フェイルオーバーが有効になっている CMD クラスターの場合**
+ クラスターを TLS なしから TLS 優先に移行すると、古いノードごとの DNS 名が削除され、新しい DNS 名が生成されるため、アプリケーションのコードではノードごとの DNS 名の代わりにプライマリエンドポイントとリーダーエンドポイントを使用してください。将来クラスターにレプリカを追加する可能性があるため、ノードごとの DNS 名を直接使用することはお勧めしません。また、自動フェイルオーバーが有効になっている場合、プライマリクラスターとレプリカのロールが ElastiCache サービスによって自動的に変更されます。これらの変更を追跡しやすくするために、プライマリエンドポイントとリーダーエンドポイントを使用することをお勧めします。最後に、リーダーエンドポイントを使用すると、レプリカからの読み取りをクラスター内のレプリカ間で均等に分散できます。
+ TLS 移行プロセス中に変更される可能性があるため、プライマリエンドポイントとリーダーエンドポイントをアプリケーションにハードコードすることはお勧めしません。TLS 優先への移行が完了したら、describe-replication-group API を使用してプライマリエンドポイントとリーダーエンドポイントをクエリし、レスポンスとして取得した DNS をこの時点から使用します。これにより、エンドポイントの変更を動的に追跡できます。
**自動フェイルオーバーが無効になっている CMD クラスターの場合**
+ アプリケーションのコードでは、ノードごとの DNS 名の代わりに、プライマリエンドポイントとリーダーエンドポイントを使用します。自動フェイルオーバーが無効になっている場合、スケーリング、パッチ、フェイルオーバー、および自動フェイルオーバーが有効な場合に ElastiCache サービスによって自動的に管理されるその他の手順は、代わりにユーザーが実行します。これにより、さまざまなエンドポイントを手動で追跡することが容易になります。クラスターを TLS なしから TLS 優先に移行する際に、古いノードごとの DNS 名は削除され、新しい DNS 名が生成されるため、ノードごとの DNS 名を直接使用しないでください。これは、TLS 移行中にクライアントがクラスターに接続するために必須です。また、リーダーエンドポイントを使用する場合、レプリカ間で読み取りを均等に分散させ、クラスターにレプリカを追加または削除するときに DNS レコードを追跡できるという利点もあります。
+ TLS 移行プロセス中に変更される可能性があるため、クラスター設定エンドポイントをアプリケーションにハードコードすることは推奨されません。
## 転送中の暗号化中: 移行プロセスが終了するタイミングに注意
転送中の暗号化モードの変更は、即座に行われるわけではなく、ある程度の時間を要することがあります。これは、大規模なクラスターの場合に特にあてはまります。クラスターが TLS 優先への移行を完了した場合にのみ、TCP 接続と TLS 接続の両方を受け入れてサービスを提供できるようになります。そのため、転送中の暗号化が完了するまでは、クラスターへの TLS 接続を確立しようとするクライアントを作成しないでください。
転送中の暗号化が成功または失敗したときに通知を受け取る方法はいくつかあります (上記のコード例には示されていません)。
+ SNS サービスを使用して暗号化が完了したときに通知を受け取る
+ 暗号化が完了するとイベントを発行する `describe-events` API を使用する
+ ElastiCache コンソールに暗号化が完了したことを示すメッセージが表示される
暗号化が完了したかどうかを確認するロジックをアプリケーションに実装することもできます。上の例では、クラスターが移行を完了したことを確認する方法をいくつか見てきました。
+ 移行プロセスが開始される (クラスターのステータスが「変更中」に変わる) まで待ち、変更が完了する (クラスターのステータスが「使用可能」に戻る) まで待つ
+ `describe-replication-group` API をクエリして、クラスターの `transit_encryption_enabled` が [True] に設定されていることを確認する。
### 転送中の暗号化を有効にした後: 使用するクライアントが正しく設定されていることを確認
クラスターが TLS 優先モードになっている間、アプリケーションはクラスターへの TLS 接続を開き、それらの接続のみを使用する必要があります。これにより、転送中の暗号化を有効にしてもアプリケーションのダウンタイムは発生しません。SSL セクションの info コマンドを使用すると、Valkey または Redis OSS エンジンへのクリアな TCP 接続がないことを確認できます。
```
# SSL
ssl_enabled:yes
ssl_current_certificate_not_before_date:Mar 20 23:27:07 2017 GMT
ssl_current_certificate_not_after_date:Feb 24 23:27:07 2117 GMT
ssl_current_certificate_serial:D8C7DEA91E684163
tls_mode_connected_tcp_clients:0 (should be zero)
tls_mode_connected_tls_clients:100
```
## Openssl を使用して、転送時の暗号化が有効なノードに接続する (Memcached)
送信中の暗号化を有効にした Memcached ノードの ElastiCache のデータにアクセスするには、Secure Socket Layer (SSL) を使用するクライアントを使用する必要があります。Amazon Linux や Amazon Linux 2 で、Openssl s\$1client を使用することもできます。
Openssl s\$1client を使用して、Amazon Linux 2 または Amazon Linux で送信中の暗号化を有効にした Memcached クラスターに接続するには:
```
/usr/bin/openssl s_client -connect memcached-node-endpoint:memcached-port
```
## Java を使用して TLS Memcached クライアントを作成する
TLS モードでクライアントを作成するには、次の操作を行って、適切な SSLContext でクライアントを初期化します。
```
import java.security.KeyStore;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManagerFactory;
import net.spy.memcached.AddrUtil;
import net.spy.memcached.ConnectionFactoryBuilder;
import net.spy.memcached.MemcachedClient;
public class TLSDemo {
public static void main(String[] args) throws Exception {
ConnectionFactoryBuilder connectionFactoryBuilder = new ConnectionFactoryBuilder();
// Build SSLContext
TrustManagerFactory tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
tmf.init((KeyStore) null);
SSLContext sslContext = SSLContext.getInstance("TLS");
sslContext.init(null, tmf.getTrustManagers(), null);
// Create the client in TLS mode
connectionFactoryBuilder.setSSLContext(sslContext);
MemcachedClient client = new MemcachedClient(connectionFactoryBuilder.build(), AddrUtil.getAddresses("mycluster.fnjyzo.cfg.use1.cache.amazonaws.com:11211"));
// Store a data item for an hour.
client.set("theKey", 3600, "This is the data value");
}
}
```
## PHP を使用して TLS Memcached クライアントを作成する
TLS モードでクライアントを作成するには、次の操作を行って、適切な SSLContext でクライアントを初期化します。
```
setOption(Memcached::OPT_CLIENT_MODE, Memcached::DYNAMIC_CLIENT_MODE);
/* Add the memcached's cluster server/s */
$tls_client->addServer($server_endpoint, $server_port);
/* Configure the client to use TLS */
if(!$tls_client->setOption(Memcached::OPT_USE_TLS, 1)) {
echo $tls_client->getLastErrorMessage(), "\n";
exit(1);
}
/* Set your TLS context configurations values.
* See MemcachedTLSContextConfig in memcached-api.php for all configurations */
$tls_config = new MemcachedTLSContextConfig();
$tls_config->hostname = '*.mycluster.fnjyzo.use1.cache.amazonaws.com';
$tls_config->skip_cert_verify = false;
$tls_config->skip_hostname_verify = false;
/* Use the created TLS context configuration object to create OpenSSL's SSL_CTX and set it to your client.
* Note: These TLS context configurations will be applied to all the servers connected to this client. */
$tls_client->createAndSetTLSContext((array)$tls_config);
/* test the TLS connection with set-get scenario: */
/* store the data for 60 seconds in the cluster.
* The client will decide which cache host will store this item.
*/
if($tls_client->set('key', 'value', 60)) {
print "Successfully stored key\n";
} else {
echo "Failed to set key: ", $tls_client->getLastErrorMessage(), "\n";
exit(1);
}
/* retrieve the key */
if ($tls_client->get('key') === 'value') {
print "Successfully retrieved key\n";
} else {
echo "Failed to get key: ", $tls_client->getLastErrorMessage(), "\n";
exit(1);
}
```
PHP クライアントの使用に関する詳細は、「[ElastiCache Cluster Client for PHP のインストール](Appendix.PHPAutoDiscoverySetup.md)」を参照してください。
# ElastiCache での保管時の暗号化
データを安全に保つために、Amazon ElastiCache と Amazon S3 には、キャッシュ内のデータへのアクセスを制限するさまざまな方法が用意されています。詳細については、「[Amazon VPC と ElastiCache のセキュリティ](VPCs.md)」および「[Amazon ElastiCache での Identity and Access Managementq](IAM.md)」を参照してください。
ElastiCache の保管時の暗号化は、ディスク上のデータを暗号化することでデータのセキュリティを強化する機能です。この機能はサーバーレスキャッシュでは常に有効になっています。有効にすると、次の要素が暗号化されます。
+ 同期、バックアップ、およびスワップオペレーション中のディスク
+ バックアップは Amazon S3 に保存されます。
データ階層化が有効なクラスター内の SSD (ソリッドステートドライブ) に保存されたデータは、常時暗号化されます。
ElastiCache は、保管時のデフォルトの (サービスマネージド) 暗号化と、Key Management Service (KMS) で独自の対称カスタマーマネージドAWS KMS キーを使用する機能を提供します。 [AWS](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html)キャッシュをバックアップするときに、暗号化オプションで、デフォルトの暗号化キーを使用するか、カスタマー管理のキーを使用するかを選択します。詳細については、「[保管時の暗号化を有効にする](#at-rest-encryption-enable)」を参照してください。
**重要**
既存のノードベースの Valkey または Redis OSS クラスターで保管時の暗号化を有効にするには、レプリケーショングループでバックアップと復元を実行した**後で**、既存のレプリケーショングループを削除する必要があります。
保管時の暗号化は、キャッシュに対してその作成時にのみ有効にできます。データの暗号化と復号を行うにはある程度の処理が必要であるため、保管時の暗号化を有効にすると、これらのオペレーションの実行中のパフォーマンスに影響を与える可能性があります。保管時の暗号化の使用時と未使用時でデータのベンチマークを取得して、ユースケースにおけるパフォーマンスの影響を判断する必要があります。
**Topics**
+ [保管時の暗号化の条件](#at-rest-encryption-constraints)
+ [KMS AWSからのカスタマーマネージドキーの使用](#using-customer-managed-keys-for-elasticache-security)
+ [保管時の暗号化を有効にする](#at-rest-encryption-enable)
+ [以下の資料も参照してください。](#at-rest-encryption-see-also)
## 保管時の暗号化の条件
ElastiCache の保管時の暗号化の実装を計画する際は、ElastiCache の保管時の暗号化の以下の制約事項に留意する必要があります。
+ 保管時の暗号化は、Valkey 7.2 以降、Redis OSS バージョン (3.2.6 は EOL の予定、「[Redis OSS versions end of life schedule](engine-versions.md#deprecated-engine-versions)」を参照)、4.0.10 以降を実行しているレプリケーショングループでサポートされます。
+ 保管時の暗号化は、Amazon VPC で実行されているレプリケーショングループでのみサポートされます。
+ 保管時の暗号化は、以下のノードタイプを実行しているレプリケーショングループでのみサポートされます。
+ R7g、R6gd、R6g、R5、R4、R3
+ M7g、M6g、M5、M4、M3
+ T4g、T3、T2
+ C7gn
詳細については、[サポートされているノードの種類](CacheNodes.SupportedTypes.md)を参照してください。
+ 保管時の暗号化は、パラメータ `AtRestEncryptionEnabled` を明示的に `true` に設定することで有効化されます。
+ 保管時の暗号化は、レプリケーショングループの作成時にのみレプリケーショングループで有効にできます。レプリケーショングループを変更して保管時の暗号化のオンとオフを切り替えることはできません。既存のレプリケーショングループ上への保管時の暗号化の実装の詳細については、「[保管時の暗号化を有効にする](#at-rest-encryption-enable)」を参照してください。
+ クラスターが r6gd ファミリのノードタイプを使用している場合、保管時の暗号化が有効になっているかどうかにかかわらず、SSD に保存されているデータは暗号化されます。
+ 保管時の暗号化にカスタマーマネージドキーを使用するオプションは、AWS GovCloud (us-gov-east-1 および us-gov-west-1) リージョンでは使用できません。
+ クラスターが r6gd ファミリーのノードタイプを使用している場合、SSD に保存されているデータは、選択したカスタマーマネージド KMS AWSキー (またはAWS GovCloud リージョンのサービスマネージド暗号化) で暗号化されます。
+ Memcached の場合、保管時の暗号化は、サーバーレスキャッシュでのみサポートされます。
+ Memcached を使用する場合、AWS GovCloud (us-gov-east-1 および us-gov-west-1) リージョンでは、保管時の暗号化にカスタマーマネージドキーを使用するオプションは利用できません。
保管時の暗号化を実装することで、バックアップオペレーションおよびノード同期オペレーションの実行中にパフォーマンスが低下する場合があります。自身のデータで保管時の暗号化使用時のベンチマークを暗号化なしの場合と比較して、実装におけるパフォーマンスの影響を判断してください。
## KMS AWSからのカスタマーマネージドキーの使用
ElastiCache は、保管時の暗号化用に対称カスタマーマネージドAWS KMS キー (KMS キー) をサポートしています。カスタマーマネージド KMS キーは、AWSアカウントで作成、所有、管理する暗号化キーです。詳細については、*AWS Key Management Service デベロッパーガイド*の「[AWS KMS キー](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#root_keys)」を参照してください。キーは、ElastiCache で使用する前にAWS KMS で作成する必要があります。
KMS ルートキーの作成方法については、AWS「 Key *AWS Management Service* [デベロッパーガイド」の](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html)「キーの作成」を参照してください。
ElastiCache では、KMS AWSと統合できます。詳細については、*AWS Key Management Service デベロッパーガイド*の「[付与の使用](https://docs.aws.amazon.com/kms/latest/developerguide/grants.html)」を参照してください。Amazon ElastiCache と KMS AWSの統合を有効にするためのカスタマーアクションは必要ありません。
`kms:ViaService` 条件キーは、KMS AWSキー (KMS キー) の使用を、指定されたAWSサービスからのリクエストに制限します。ElastiCacheとともに `kms:ViaService` を使用するには、`elasticache.AWS_region.amazonaws.com` と`dax.AWS_region.amazonaws.com` の条件キーの値に両方のViaService 名を含めます。詳細については、「[kms:ViaService](https://docs.aws.amazon.com/kms/latest/developerguide/policy-conditions.html#conditions-kms-via-service)」を参照してください。
[AWS CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-user-guide.html) を使用して、Amazon ElastiCache によってお客様に代わってAWS Key Management Serviceに送信されるリクエストを追跡できます。カスタマーマネージドキーAWS Key Management Serviceに関連する へのすべての API コールには、対応する CloudTrail ログがあります。[ListGrants](https://docs.aws.amazon.com/kms/latest/APIReference/API_ListGrants.html) KMS API コールを行うことで、ElastiCache によって作成される許可を表示することもできます。
カスタマー管理のキーを使用してレプリケーショングループが暗号化されると、レプリケーショングループのすべてのバックアップは以下のように暗号化されます。
+ 毎日の自動バックアップは、クラスターに関連付けられたカスタマー管理のキーを使用して暗号化されます。
+ レプリケーショングループが削除されたときに作成される最終バックアップも、レプリケーショングループに関連付けられたカスタマー管理のキーを使用して暗号化されます。
+ 手動で作成されたバックアップは、デフォルトで、レプリケーショングループに関連付けられた KMS キーを使用して暗号化されます。この動作は、別のカスタマー管理のキーを選択して上書きできます。
+ バックアップをコピーするとき、デフォルトでは、ソースバックアップに関連付けられたカスタマー管理のキーが使用されます。この動作は、別のカスタマー管理のキーを選択して上書きできます。
**注記**
選択した Amazon S3 バケットにバックアップをエクスポートするとき、カスタマー管理のキーは使用できません。ただし、Amazon S3 にエクスポートされたすべてのバックアップは、[サーバー側の暗号化](https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingServerSideEncryption.html)を使用して暗号化されます。バックアップファイルを新しい S3 オブジェクトにコピーし、カスタマー管理の KMS キーを使用して暗号化するか、デフォルトの暗号化が設定された別の S3 バケットにコピーし、KMS キーを使用して暗号化するか、ファイル自体の暗号化オプションを変更できます。
また、暗号化にカスタマー管理のキーを使用しないレプリケーショングループに手動で作成されたバックアップを、カスタマー管理のキーを使用して暗号化することもできます。このオプションでは、データが元のレプリケーショングループで暗号化されていなくても、Amazon S3 に保存されているバックアップファイルは KMS キーを使用して暗号化されます。
バックアップから復元するときは、新しいレプリケーショングループの作成時に使用できるものと同様の暗号化オプションから選択できます。
+ キーを削除するか、キーを[無効化](https://docs.aws.amazon.com/kms/latest/developerguide/enabling-keys.html)して、キャッシュの暗号化に使用したキーの[許可を取り消す](https://docs.aws.amazon.com/kms/latest/APIReference/API_RevokeGrant.html)と、キャッシュは回復不可能になります。 つまり、ハードウェア障害後に変更または復旧することはできません。AWS KMS は、少なくとも 7 日間の待機期間後にのみルートキーを削除します。キーが削除された後、別のカスタマー管理のキーを使用して、アーカイブ目的のバックアップを作成できます。
+ 自動キーローテーションは KMS AWSルートキーのプロパティを保持するため、ローテーションは ElastiCache データにアクセスする機能には影響しません。暗号化された Amazon ElastiCache キャッシュは、手動キー更新をサポートしていないため、新しいルートキーの作成や古いキーへの参照の更新などを行うことはできません。詳細については、「 Key Management Service [AWSデベロッパーガイド」の「KMS キーのローテーション](https://docs.aws.amazon.com/kms/latest/developerguide/rotate-keys.html)」を参照してください。 *AWS*
+ KMS キーを使用して ElastiCache キャッシュを暗号化するには、キャッシュごとに 1 つの許可が必要です。この許可はキャッシュの有効期間を通じて使用されます。また、バックアップの作成中、バックアップごとに 1 つの許可が使用されます。この許可はバックアップの作成後に無効になります。
+ KMS AWSの許可と制限の詳細については、*AWS「 Key Management Service デベロッパーガイド*」の[「制限](https://docs.aws.amazon.com/kms/latest/developerguide/limits.html)」を参照してください。
## 保管時の暗号化を有効にする
すべてのサーバーレスキャッシュでは、保管時の暗号化が有効になっています。
ノードベースのクラスターを作成する場合は、パラメータ `AtRestEncryptionEnabled` を `true` に設定することで保管時の暗号化を有効にできます。既存のレプリケーショングループ上で保管時の暗号化を有効にすることはできません。
保管時の暗号化は、ElastiCache キャッシュの作成時に有効化できます。これを行うにはAWS マネジメントコンソール、AWS CLI、、または ElastiCache API を使用します。
キャッシュを作成するときに、以下のオプションのいずれかを選択できます。
+ **デフォルト** - このオプションでは、サービス管理の保存時の暗号化が使用されます。
+ **カスタマーマネージドキー ** – このオプションを使用すると、KMS からのキー ID/ARN AWSを保管時の暗号化用に指定できます。
KMS ルートキーの作成方法については、AWS「 Key *AWS Management Service* [デベロッパーガイド」の](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html)「キーの作成」を参照してください。
**Contents**
+ [を使用した保管時の暗号化の有効化AWS マネジメントコンソール](#at-rest-encryption-enable-con)
+ [を使用した保管時の暗号化の有効化AWS CLI](#at-rest-encryption-enable-cli)
### 既存のノードベースの Valkey または Redis OSS クラスター上で保管時の暗号化を有効にする
保管時の暗号化は、Valkey または Redis OSS レプリケーショングループの作成時にのみ有効化できます。保管時の暗号化を有効化したい既存レプリケーショングループがある場合は、次の操作を行います。
**既存のレプリケーショングループ上で保管時の暗号化を有効にするには**
1. 既存のレプリケーショングループの手動バックアップを作成します。詳細については、「[手動バックアップの取得](backups-manual.md)」を参照してください。
1. バックアップから復元して新しいレプリケーショングループを作成します。新しいレプリケーショングループで、保管時の暗号化を有効にします。詳細については、「[バックアップから新しいキャッシュへの復元](backups-restoring.md)」を参照してください。
1. アプリケーションのエンドポイントを、新しいレプリケーショングループのエンドポイントに更新します。
1. 古いレプリケーショングループを削除します。詳細については、[ElastiCache でのクラスターの削除](Clusters.Delete.md)または[レプリケーショングループの削除](Replication.DeletingRepGroup.md)を参照してください。
### を使用した保管時の暗号化の有効化AWS マネジメントコンソール
#### サーバーレスキャッシュで保管時の暗号化を有効にする (コンソール)
すべてのサーバーレスキャッシュでは、保管時の暗号化が有効になっています。デフォルトでは、AWS所有の KMS キーを使用してデータを暗号化します。独自のAWS KMSキーを選択するには、次の選択を行います。
+ **[デフォルト設定]** セクションを展開します。
+ **[デフォルト設定]** セクションで **[デフォルト設定をカスタマイズ]** を選択します。
+ **[セキュリティ]** セクションで **[セキュリティ設定をカスタマイズ]** を選択します。
+ **[暗号化キー]** 設定で **[カスタマーマネージド CMK]** を選択します。
+ **[AWS KMSキー]** 設定でキーを選択します。
#### ノードベースのクラスター上で保管時の暗号化を有効にする (コンソール)
独自のキャッシュを設計する場合、[簡易作成] 方式の [開発/テスト] 設定と [本番稼働用]設定では、**[デフォルト]** キーを使用する保管時の暗号化が有効になっています。設定を自分で選択するときは、以下のように選択します。
+ エンジンのバージョンとしてバージョン 3.2.6、4.0.10 またはそれ以降を選択します。
+ **[保管時の暗号化]** オプションの **[有効化]** の横にあるチェックボックスをオンにします。
+ **[デフォルトキー]** または **[カスタマーマネージド CMK]** を選択します。
詳しい手順については、以下を参照ください。
+ [Valkey (クラスターモードが無効) クラスターの作成 (コンソール)](SubnetGroups.designing-cluster-pre.valkey.md#Clusters.Create.CON.valkey-gs)
+ [Valkey または Redis OSS (クラスターモードが有効) クラスターの作成 (コンソール)](Clusters.Create.md#Clusters.Create.CON.RedisCluster)
### を使用した保管時の暗号化の有効化AWS CLI
を使用して Valkey または Redis OSS クラスターを作成するときに保管時の暗号化を有効にするにはAWS CLI、レプリケーショングループを作成するときに *--at-rest-encryption-enabled* パラメータを使用します。
#### Valkey または Redis OSS (クラスターモードが無効) クラスターで保管時の暗号化を有効にする (CLI)
次のオペレーションでは、3 つのノード (*--num-cache-clusters*)、1 つのプライマリ、2 つのリードレプリカを持つ Valkey または Redis OSS (クラスターモードが無効) レプリケーショングループ `my-classic-rg` を作成します。保管時の暗号化は、このレプリケーショングループに対して有効です (*--at-rest-encryption-enabled*)。
以下のパラメータとその値は、このレプリケーショングループで暗号化を有効にするために必要です。
**主要パラメータ**
+ **--engine** — `valkey` または `redis` を指定する必要があります。
+ **--engine-version** — エンジンが Redis OSS の場合、3.2.6、4.0.10 以降である必要があります。
+ **--at-rest-encryption-enabled** — 保管時の暗号化に必要です。
**Example 1: レプリカがある Valkey または Redis OSS (クラスターモードが無効) クラスター**
Linux、macOS、Unix の場合:
```
aws elasticache create-replication-group \
--replication-group-id my-classic-rg \
--replication-group-description "3 node replication group" \
--cache-node-type cache.m4.large \
--engine redis \
--at-rest-encryption-enabled \
--num-cache-clusters 3
```
Windows の場合:
```
aws elasticache create-replication-group ^
--replication-group-id my-classic-rg ^
--replication-group-description "3 node replication group" ^
--cache-node-type cache.m4.large ^
--engine redis ^
--at-rest-encryption-enabled ^
--num-cache-clusters 3 ^
```
詳細については、以下を参照してください。
+ [Valkey または Redis OSS (クラスターモードが無効) レプリケーショングループを最初から作成する (AWS CLI)](Replication.CreatingReplGroup.NoExistingCluster.Classic.md#Replication.CreatingReplGroup.NoExistingCluster.Classic.CLI)
+ [create-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html)
#### Valkey または Redis OSS (クラスターモードが有効) のクラスターで保管時の暗号化を有効にする (CLI)
次のオペレーションでは、3 つのノードグループまたはシャード (*--num-node-groups*) を持つ Valkey または Redis OSS (クラスターモードが有効) レプリケーショングループ `my-clustered-rg` を作成します。各レプリケーショングループには、1 つのプライマリ、および 2 つのリードレプリカ (*--replicas-per-node-group*) があります。保管時の暗号化は、このレプリケーショングループに対して有効です (*--at-rest-encryption-enabled*)。
以下のパラメータとその値は、このレプリケーショングループで暗号化を有効にするために必要です。
**主要パラメータ**
+ **--engine** — `valkey` または `redis` を指定する必要があります。
+ **--engine-version** — エンジンが Redis OSS の場合、4.0.10 以降である必要があります。
+ **--at-rest-encryption-enabled** — 保管時の暗号化に必要です。
+ **--cache-parameter-group** — `default-redis4.0.cluster.on`、またはこれをクラスターモードが有効なレプリケーショングループにするために、それから算出されたいずれかに指定する必要があります。
**Example 2: Valkey または Redis OSS (クラスターモードが有効) クラスター**
Linux、macOS、Unix の場合:
```
aws elasticache create-replication-group \
--replication-group-id my-clustered-rg \
--replication-group-description "redis clustered cluster" \
--cache-node-type cache.m3.large \
--num-node-groups 3 \
--replicas-per-node-group 2 \
--engine redis \
--engine-version 6.2 \
--at-rest-encryption-enabled \
--cache-parameter-group default.redis6.x.cluster.on
```
Windows の場合:
```
aws elasticache create-replication-group ^
--replication-group-id my-clustered-rg ^
--replication-group-description "redis clustered cluster" ^
--cache-node-type cache.m3.large ^
--num-node-groups 3 ^
--replicas-per-node-group 2 ^
--engine redis ^
--engine-version 6.2 ^
--at-rest-encryption-enabled ^
--cache-parameter-group default.redis6.x.cluster.on
```
詳細については、以下を参照してください。
+ [Valkey または Redis OSS (クラスターモードが有効) レプリケーショングループを最初から作成する (AWS CLI)](Replication.CreatingReplGroup.NoExistingCluster.Cluster.md#Replication.CreatingReplGroup.NoExistingCluster.Cluster.CLI)
+ [create-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html)
## 以下の資料も参照してください。
+ [Amazon VPC と ElastiCache のセキュリティ](VPCs.md)
+ [Amazon ElastiCache での Identity and Access Managementq](IAM.md)
# 認証と認可
AWS Identity and Access Management (IAM) は、AWS リソースへのアクセスを安全に制御するためのウェブサービスです。ElastiCache では、IAM と Valkey および Redis OSS AUTH コマンドを使用したユーザーの認証と、ロールベースのアクセスコントロール (RBAC) を使用したユーザーオペレーションの承認をサポートします。
**Topics**
+ [ロールベースのアクセスコントロール (RBAC)](Clusters.RBAC.md)
+ [Valkey および Redis OSS AUTH コマンドによる認証](auth.md)
+ [ElastiCache Valkey または Redis OSS キャッシュでアクセスコントロールを無効にする](in-transit-encryption-disable.md)
# ロールベースのアクセスコントロール (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());
}
}
```
# Valkey および Redis OSS AUTH コマンドによる認証
**注記**
**AUTH** は [ロールベースのアクセスコントロール (RBAC)](Clusters.RBAC.md) に置き換えられました。すべてのサーバーレスキャッシュでは、認証時に RBAC を使用する必要があります。
Valkey および Redis OSS 認証トークン、またはパスワードにより、Valkey および Redis OSS はクライアントにコマンドの実行を許可する前にパスワードを要求できるため、データのセキュリティが向上します。**AUTH** はノードベースのクラスターでのみ使用できます。
**Topics**
+ [Valkey と Redis OSS に対応した ElastiCache の AUTH の概要](#auth-overview)
+ [Valkey と Redis OSS に対応した ElastiCache クラスターへの認証の適用](#auth-using)
+ [既存のクラスターでの AUTH トークンの変更](#auth-modifyng-token)
+ [RBAC から AUTH への移行](#Migrate-From-RBAC-to-AUTH)
## Valkey と Redis OSS に対応した ElastiCache の AUTH の概要
Valkey と Redis OSS に対応した ElastiCache クラスターで **AUTH** を使用する場合、微調整がいくつかあります。
特に、AUTH を使用する場合は、AUTH トークンまたはパスワードに関する以下の制約に注意してください。
+ トークン、またはパスワードは、印刷可能な 16～128 文字である必要があります。
+ 英数字以外の文字は、(\$1、&、\$1、\$1、^、<、>、-) に制限されています。
+ AUTH は、送信中の暗号化が有効な Valkey または Redis OSS のクラスターでのみ有効にできます。
強力なトークンを設定するには、以下の要件を満たすなど、厳格なパスワードポリシーに従うことをお勧めします。
+ トークンまたはパスワードには、以下の種類から 3 種類以上の文字が含まれている必要があります。
+ 英大文字
+ 英小文字
+ 数字
+ アルファベット以外の文字 (`!`、`&`、`#`、`$`、`^`、`<`、`>`、`-`)
+ トークンまたはパスワードに、辞書に載っている単語またはそれを少し変更したような単語を使用することはできません。
+ トークンまたはパスワードは、最近使用したトークンと同じまたは類似していてはなりません。
## Valkey と Redis OSS に対応した ElastiCache クラスターへの認証の適用
トークンで保護された Valkey または Redis OSS サーバーでユーザーにトークン (パスワード) の入力を要求できます。そのためには、レプリケーショングループまたはクラスターを作成するときに、正しいトークンを指定したパラメータ `--auth-token` (API: `AuthToken`) を含めます。また、レプリケーショングループまたはクラスターに対する後続のすべてのコマンドにもそのパラメータを含めます。
次のAWS CLIオペレーションでは、転送中の暗号化 (TLS) を有効にし、**AUTH**トークン を使用してレプリケーショングループを作成します`This-is-a-sample-token`。サブネット グループ `sng-test` を、実存のサブネットグループに置き換えます。
**キーのパラメータ**
+ **--engine** — `valkey` または `redis` を指定する必要があります。
+ **--engine-version** — エンジンが Redis OSS の場合、3.2.6、4.0.10 以降である必要があります。
+ **--transit-encryption-enabled** — 認証と HIPAA 適格性に必要です。
+ **--auth-token** — HIPAA 適格性に必要です。この値は、このトークンで保護された Valkey または Redis OSS サーバーの正しいトークンであることが必要です。
+ **--cache-subnet-group** — HIPAA 適格性に必要です。
Linux、macOS、Unix の場合:
```
aws elasticache create-replication-group \
--replication-group-id authtestgroup \
--replication-group-description authtest \
--engine redis \
--cache-node-type cache.m4.large \
--num-node-groups 1 \
--replicas-per-node-group 2 \
--transit-encryption-enabled \
--auth-token This-is-a-sample-token \
--cache-subnet-group sng-test
```
Windows の場合:
```
aws elasticache create-replication-group ^
--replication-group-id authtestgroup ^
--replication-group-description authtest ^
--engine redis ^
--cache-node-type cache.m4.large ^
--num-node-groups 1 ^
--replicas-per-node-group 2 ^
--transit-encryption-enabled ^
--auth-token This-is-a-sample-token ^
--cache-subnet-group sng-test
```
## 既存のクラスターでの AUTH トークンの変更
認証の更新を容易にするために、クラスターで使用される **AUTH** トークンを変更できます。エンジンバージョンが Valkey 7.2 以降または Redis 5.0.6 以降であれば、この変更を行うことができます。ElastiCache では、転送中の暗号化も有効にする必要があります。
認証トークンの変更は、ROTATE と SET の 2 つの戦略をサポートしています。ROTATE 戦略では、以前のトークンを保持しながら、サーバーに別の AUTH トークンを追加します。SET 戦略では、1 つの AUTH トークンのみをサポートするように、サーバーを更新します。変更をすぐに適用するには、これらの変更の呼び出しで `--apply-immediately` パラメータを指定します。
### AUTH トークンの更新
Valkey または Redis OSS サーバーを新しい **AUTH トークン**で更新するには、`--auth-token` パラメータで新しい **AUTH** トークンを指定し、`--auth-token-update-strategy` で値 ROTATE を指定して、`ModifyReplicationGroup` API を呼び出します。ROTATE 変更が完了すると、クラスターは `auth-token` パラメータで指定された AUTH トークンに加えて、以前の AUTH トークンをサポートします。AUTH トークンローテーションの前にレプリケーショングループに AUTH トークンが設定されていない場合、クラスターは認証なしの接続をサポートするだけでなく、`--auth-token` パラメータで指定された AUTH トークンもサポートします。更新戦略 SET を使用して AUTH トークンを必須に更新するには、「[AUTH トークンの設定](#auth-modifying-set)」を参照してください。
**注記**
AUTH トークンを前もって設定しない場合、変更が完了すると、クラスターは auth-token パラメータで指定されたもの以外の AUTH トークンをサポートしません。
すでに 2 つの AUTH トークンをサポートするサーバーに対してこの変更が行われると、最も古い AUTH トークンもこのオペレーション中に削除されます。これにより、サーバーは一度に最大 2 つの最新の AUTH トークンをサポートできます。
この時点で、最新の AUTH トークンを使用するようにクライアントを更新することで続行できます。クライアントが更新された後、**AUTH** トークンの更新に関する SET 戦略 (次のセクションで説明) を採用して、新しいトークンのみの使用を開始できます。
次のAWS CLIオペレーションでは、**AUTH**トークン をローテーションするようにレプリケーショングループを変更します`This-is-the-rotated-token`。
Linux、macOS、Unix の場合:
```
aws elasticache modify-replication-group \
--replication-group-id authtestgroup \
--auth-token This-is-the-rotated-token \
--auth-token-update-strategy ROTATE \
--apply-immediately
```
Windows の場合:
```
aws elasticache modify-replication-group ^
--replication-group-id authtestgroup ^
--auth-token This-is-the-rotated-token ^
--auth-token-update-strategy ROTATE ^
--apply-immediately
```
### AUTH トークンの設定
Valkey または Redis OSS サーバーを更新して単一の必須 **AUTH** トークンをサポートするには、最後の AUTH トークンと同じ値で `--auth-token` パラメータを指定し、値 `SET` で `--auth-token-update-strategy` パラメータを指定して、`ModifyReplicationGroup` API オペレーションを呼び出します。SET 戦略は、以前に ROTATE 戦略を使用することで 2 つの AUTH トークンまたは 1 つのオプションの AUTH トークンを持つクラスターでのみ使用できます。この変更が完了すると、サーバーは、auth-token パラメータで指定された AUTH トークンのみをサポートするようになります。
次のAWS CLIオペレーションでは、レプリケーショングループを変更して AUTH トークンを に設定します`This-is-the-set-token`。
Linux、macOS、Unix の場合:
```
aws elasticache modify-replication-group \
--replication-group-id authtestgroup \
--auth-token This-is-the-set-token \
--auth-token-update-strategy SET \
--apply-immediately
```
Windows の場合:
```
aws elasticache modify-replication-group ^
--replication-group-id authtestgroup ^
--auth-token This-is-the-set-token ^
--auth-token-update-strategy SET ^
--apply-immediately
```
### 既存のクラスターでの認証の有効化
既存の Valkey または Redis OSS サーバーで認証を有効にするには、`ModifyReplicationGroup` API オペレーションを呼び出します。`--auth-token` パラメータで新しいトークンを指定し、`--auth-token-update-strategy` パラメータで値 ROTATE を指定して、`ModifyReplicationGroup` を呼び出します。
ROTATE 変更が完了すると、クラスターは、認証なしの接続をサポートするだけでなく、`--auth-token` パラメータで指定された **AUTH** トークンもサポートするようになります。AUTH トークンを使用して Valkey または Redis OSS への認証を行うようにすべてのクライアントアプリケーションが更新されたら、SET 戦略を使用して AUTH トークンを必要に応じてマークします。認証の有効化は、転送中の暗号化 (TLS) が有効な Valkey または Redis OSS サーバーでのみサポートされます。
## RBAC から AUTH への移行
「[ロールベースのアクセスコントロール (RBAC)](Clusters.RBAC.md)」で説明されているように、Valkey または Redis OSS のロールベースのアクセスコントロール (RBAC) を使用してユーザーを認証していて、AUTH に移行する場合は、次の手順を使用します。コンソールまたは CLI を使用して移行できます。
**コンソールを使用して RBAC から AUTH に移行するには**
1. にサインインAWS マネジメントコンソールし、[https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/) で ElastiCache コンソールを開きます。
1. 右上隅のリストから、変更するクラスターがあるAWSリージョンを選択します。
1. ナビゲーションペインで、変更するクラスターで実行されているエンジンを選択します。
選択したエンジンのクラスターが一覧表示されます。
1. クラスターのリストで、変更するクラスターの名前を選択します。
1. **[アクション]**、**[変更]** の順に選択します。
**[変更]** ウィンドウが表示されます。
1. **[アクセスコントロール]** で、**[Valkey 認証デフォルトユーザーアクセス]** または **[Redis OSS 認証デフォルトユーザーアクセス]** を選択します。
1. **[Valkey 認証トークン]** または **[Redis OSS 認証トークン]** で、新しいトークンを設定します。
1. **[変更をプレビュー]** を選択し、次の画面で **[変更]** を選択します。
**を使用して RBAC から AUTH に移行するにはAWS CLI**
次のいずれかのコマンドを使用して、Valkey または Redis OSS レプリケーショングループの新しいオプションの **AUTH** トークンを設定します。オプションの Auth トークンでは、次のステップで更新戦略 `SET` を使用して、Auth トークンが必須としてマークされるまで、レプリケーショングループへの未認証アクセスが許可されます。
Linux、macOS、Unix の場合:
```
aws elasticache modify-replication-group \
--replication-group-id test \
--remove-user-groups \
--auth-token This-is-a-sample-token \
--auth-token-update-strategy ROTATE \
--apply-immediately
```
Windows の場合:
```
aws elasticache modify-replication-group ^
--replication-group-id test ^
--remove-user-groups ^
--auth-token This-is-a-sample-token ^
--auth-token-update-strategy ROTATE ^
--apply-immediately
```
上記のコマンドを実行した後、新しく設定されたオプションの AUTH トークンを使用して、Valkey または Redis OSS アプリケーションを更新して ElastiCache レプリケーショングループに対して認証できます。Auth トークンローテーションを完了するには、次のコマンドで更新戦略 `SET` を使用します。これにより、オプションの AUTH トークンが必須としてマークされます。Auth トークンの更新が完了すると、レプリケーショングループのステータスは `ACTIVE` として表示され、このレプリケーショングループへのすべての接続には認証が必要になります。
Linux、macOS、Unix の場合:
```
aws elasticache modify-replication-group \
--replication-group-id test \
--auth-token This-is-a-sample-token \
--auth-token-update-strategy SET \
--apply-immediately
```
Windows の場合:
```
aws elasticache modify-replication-group ^
--replication-group-id test ^
--remove-user-groups ^
--auth-token This-is-a-sample-token ^
--auth-token-update-strategy SET ^
--apply-immediately
```
詳細については、「[Valkey および Redis OSS AUTH コマンドによる認証](#auth)」を参照してください。
**注記**
ElastiCache クラスターのアクセスコントロールを無効にする必要がある場合は、「[ElastiCache Valkey または Redis OSS キャッシュでアクセスコントロールを無効にする](in-transit-encryption-disable.md)」を参照してください。
# ElastiCache Valkey または Redis OSS キャッシュでアクセスコントロールを無効にする
以下の手順に従って、TLS が有効な Valkey または Redis OSS キャッシュでアクセスコントロールを無効にします。キャッシュには、AUTH デフォルトユーザーアクセスまたはユーザーグループのアクセスコントロールリスト (RBAC) の 2 種類の構成のいずれかが設定されます。キャッシュが AUTH 構成で作成された場合は、ユーザーグループを削除してキャッシュを無効にする前に、RBAC 構成に変更する必要があります。キャッシュが RBAC 構成で作成されている場合は、そのまま無効にできます。
**RBAC で構成された Valkey または Redis OSS サーバーレスキャッシュを無効にするには**
1. ユーザーグループを削除してアクセスコントロールを無効にします。
```
aws elasticache modify-serverless-cache --serverless-cache-name --remove-user-group
```
1. (オプション) サーバーレスキャッシュにユーザーグループが関連付けられていないことを確認します。
```
aws elasticache describe-serverless-caches --serverless-cache-name
{
"..."
"UserGroupId": ""
"..."
}
```
**AUTH トークンで構成された Valkey または Redis OSS キャッシュを無効にするには**
1. AUTH トークンを RBAC に変更し、追加するユーザーグループを指定します。
```
aws elasticache modify-replication-group --replication-group-id --auth-token-update-strategy DELETE --user-group-ids-to-add
```
1. AUTH トークンが無効になり、ユーザーグループが追加されたことを確認します。
```
aws elasticache describe-replication-groups --replication-group-id
{
"..."
"AuthTokenEnabled": false,
"UserGroupIds": [
""
]
"..."
}
```
1. ユーザーグループを削除してアクセスコントロールを無効にします。
```
aws elasticache modify-replication-group --replication-group-id --user-group-ids-to-remove
{
"..."
"PendingModifiedValues": {
"UserGroups": {
"UserGroupIdsToAdd": [],
"UserGroupIdsToRemove": [
""
]
}
"..."
}
```
1. (オプション) クラスターにユーザーグループが関連付けられていないことを確認します。`AuthTokenEnabled` フィールドも false と表示されるはずです。
```
aws elasticache describe-replication-groups --replication-group-id
"AuthTokenEnabled": false
```
**RBAC で構成された Valkey または Redis OSS クラスターを無効にするには**
1. ユーザーグループを削除してアクセスコントロールを無効にします。
```
aws elasticache modify-replication-group --replication-group-id --user-group-ids-to-remove
{
"..."
"PendingModifiedValues": {
"UserGroups": {
"UserGroupIdsToAdd": [],
"UserGroupIdsToRemove": [
""
]
}
"..."
}
```
1. (オプション) クラスターにユーザーグループが関連付けられていないことを確認します。`AuthTokenEnabled` フィールドも false と表示されるはずです。
```
aws elasticache describe-replication-groups --replication-group-id
"AuthTokenEnabled": false
```