翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。
# Amazon ElastiCache の使用を開始する
このセクションのハンズオンチュートリアルを使用して ElastiCache の使用を開始し、詳しく学習します。
**Topics**
+ [ElastiCache のセットアップ](set-up.md)
+ [Valkey サーバーレスキャッシュの作成](GettingStarted.serverless-valkey.step1.md)
+ [Redis OSS のサーバーレスキャッシュを作成する](GettingStarted.serverless-redis.step1.md)
+ [Memcached サーバーレスキャッシュを作成する](create-serverless-cache-mem.md)
+ [チュートリアル: Python と ElastiCache の開始方法](ElastiCache-Getting-Started-Tutorials.md)
+ [チュートリアル: VPC 内で ElastiCache にアクセスするための Lambda の設定](LambdaRedis.md)
# ElastiCache のセットアップ
ElastiCache ウェブサービスを使用するには、以下の手順に従います。
**Topics**
+ [にサインアップするAWS アカウント](#sign-up-for-aws)
+ [管理アクセスを持つユーザーを作成する](#create-an-admin)
+ [プログラム的なアクセス権を付与する](#elasticache-set-up-access-key)
+ [アクセス許可の設定](#elasticache-set-up-permissions)
+ [EC2 をセットアップする](#elasticache-install-configure-ec2)
+ [ネットワークアクセスを許可する](#elasticache-install-grant-access-VPN)
+ [コマンドラインアクセスをセットアップする](#Download-and-install-cli)
## にサインアップするAWS アカウント
がない場合はAWS アカウント、次の手順を実行して作成します。
**にサインアップするにはAWS アカウント**
1. [https://portal.aws.amazon.com/billing/signup](https://portal.aws.amazon.com/billing/signup) を開きます。
1. オンラインの手順に従います。
サインアップ手順の一環として、電話またはテキストメッセージを受け取り、電話キーパッドで検証コードを入力します。
にサインアップするとAWS アカウント、 *AWS アカウントのルートユーザー* が作成されます。ルートユーザーには、アカウントのすべてのAWS のサービスとリソースへのアクセス権があります。セキュリティベストプラクティスとして、ユーザーに管理アクセス権を割り当て、[ルートユーザーアクセスが必要なタスク](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks)の実行にはルートユーザーのみを使用するようにしてください。
AWSサインアッププロセスが完了すると、 から確認メールが送信されます。[https://aws.amazon.com/](https://aws.amazon.com/) の **[マイアカウント]** をクリックして、いつでもアカウントの現在のアクティビティを表示し、アカウントを管理することができます。
## 管理アクセスを持つユーザーを作成する
にサインアップしたらAWS アカウント、日常的なタスクにルートユーザーを使用しないようにAWS アカウントのルートユーザー、 を保護しAWS IAM アイデンティティセンター、 を有効にして管理ユーザーを作成します。
**を保護するAWS アカウントのルートユーザー**
1. **ルートユーザー**を選択し、AWS アカウント E メールアドレスを入力して、アカウント所有者[AWS マネジメントコンソール](https://console.aws.amazon.com/)として にサインインします。次のページでパスワードを入力します。
ルートユーザーを使用してサインインする方法については、「*AWS サインインユーザーガイド*」の「[ルートユーザーとしてサインインする](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial)」を参照してください。
1. ルートユーザーの多要素認証 (MFA) を有効にします。
手順については、*IAM* [ユーザーガイドのAWS アカウント「ルートユーザー (コンソール) の仮想 MFA デバイス](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html)を有効にする」を参照してください。
**管理アクセスを持つユーザーを作成する**
1. IAM アイデンティティセンターを有効にします。
手順については、「AWS IAM アイデンティティセンターユーザーガイド」の「[AWS IAM アイデンティティセンターの有効化](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html)」を参照してください。
1. IAM アイデンティティセンターで、ユーザーに管理アクセスを付与します。
を ID ソースIAM アイデンティティセンターディレクトリとして使用する方法のチュートリアルについては、*AWS IAM アイデンティティセンター「 ユーザーガイド*」の[「デフォルトを使用してユーザーアクセスを設定するIAM アイデンティティセンターディレクトリ](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html)」を参照してください。
**管理アクセス権を持つユーザーとしてサインインする**
+ IAM アイデンティティセンターのユーザーとしてサインインするには、IAM アイデンティティセンターのユーザーの作成時に E メールアドレスに送信されたサインイン URL を使用します。
IAM Identity Center ユーザーを使用してサインインする方法については、*AWS サインイン「 ユーザーガイド*[」のAWS「 アクセスポータルにサインイン](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html)する」を参照してください。
**追加のユーザーにアクセス権を割り当てる**
1. IAM アイデンティティセンターで、最小特権のアクセス許可を適用するというベストプラクティスに従ったアクセス許可セットを作成します。
手順については、「*AWS IAM アイデンティティセンターユーザーガイド*」の「[アクセス許可セットを作成する](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html)」を参照してください。
1. グループにユーザーを割り当て、そのグループにシングルサインオンアクセス権を割り当てます。
手順については、「*AWS IAM アイデンティティセンターユーザーガイド*」の「[グループの追加](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html)」を参照してください。
## プログラム的なアクセス権を付与する
ユーザーが のAWS外部で を操作する場合は、プログラムによるアクセスが必要ですAWS マネジメントコンソール。プログラムによるアクセスを許可する方法は、 がアクセスするユーザーのタイプによって異なりますAWS。
ユーザーにプログラムによるアクセス権を付与するには、以下のいずれかのオプションを選択します。
****
| プログラムによるアクセス権を必要とするユーザー | 目的 | 方法 |
| --- | --- | --- |
| IAM | (推奨) コンソール認証情報を一時的な認証情報として使用してAWS CLI、、AWS SDKs、またはAWS APIs。 | 使用するインターフェイスの指示に従ってください。 [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/AmazonElastiCache/latest/dg/set-up.html) |
| ワークフォースアイデンティティ (IAM アイデンティティセンターで管理されているユーザー) | 一時的な認証情報を使用してAWS CLI、、AWS SDKs、またはAWS APIs。 | 使用するインターフェイスの指示に従ってください。 [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/AmazonElastiCache/latest/dg/set-up.html) |
| IAM | 一時的な認証情報を使用してAWS CLI、、AWS SDKs、またはAWS APIs。 | 「IAM [ユーザーガイド」の「AWSリソースでの一時的な認証情報](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html)の使用」の手順に従います。 |
| IAM | (非推奨)長期認証情報を使用して、AWS CLI、AWS SDKs、またはAWS APIs。 | 使用するインターフェイスの指示に従ってください。 [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/AmazonElastiCache/latest/dg/set-up.html) |
**関連トピック:**
+ *IAM ユーザーガイド*の [IAM とは](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html)
+ *AWS全般のリファレンス*の[AWS「セキュリティ認証情報](https://docs.aws.amazon.com/general/latest/gr/aws-security-credentials.html)」。
## アクセス許可を設定する (新規の ElastiCache ユーザーのみ)
アクセス権限を付与するにはユーザー、グループ、またはロールにアクセス許可を追加します。
+ のユーザーとグループAWS IAM アイデンティティセンター:
アクセス許可セットを作成します。「*AWS IAM アイデンティティセンターユーザーガイド*」の「[アクセス許可セットを作成する](https://docs.aws.amazon.com//singlesignon/latest/userguide/howtocreatepermissionset.html)」の手順に従ってください。
+ IAM 内で、ID プロバイダーによって管理されているユーザー:
ID フェデレーションのロールを作成します。詳細については *IAM ユーザーガイド* の [サードパーティー ID プロバイダー (フェデレーション) 用のロールを作成する](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-idp.html) を参照してください。
+ IAM ユーザー:
+ ユーザーが担当できるロールを作成します。手順については *IAM ユーザーガイド* の [IAM ユーザーのロールの作成](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-user.html) を参照してください。
+ (お奨めできない方法) ポリシーをユーザーに直接アタッチするか、ユーザーをユーザーグループに追加します。*IAM ユーザーガイド* の [ユーザー (コンソール) へのアクセス許可の追加](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_users_change-permissions.html#users_change_permissions-add-console) の指示に従います。
Amazon ElastiCache はサービスにリンクされたロールを作成し、それを使ってリソースをプロビジョニングして、お客様の代わりに他のAWSリソースとサービスにアクセスします。ElastiCache がサービスにリンクされたロールを作成するには、 という名前AWSの管理ポリシーを使用します`AmazonElastiCacheFullAccess`。このロールには、サービスにリンクされたロールをサービスがユーザーに代わって作成するために必要なアクセス許可が事前に設定されています。
デフォルトのポリシーを使用せず、代わりにカスタムマネージドポリシーを使用することもできます。この場合、`iam:createServiceLinkedRole` を呼び出すアクセス許可を持っているか、自分が ElastiCache サービスにリンクされたロールを作成している必要があります。
詳細については次を参照してください:
+ [新しいポリシーの作成](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html) (IAM)
+ [AWS Amazon ElastiCache の マネージドポリシー](IAM.IdentityBasedPolicies.PredefinedPolicies.md)
+ [Amazon ElastiCache でのサービスにリンクされたロールの使用](using-service-linked-roles.md)
## EC2 をセットアップする
キャッシュに接続する EC2 インスタンスを設定する必要があります。
+ EC2 インスタンスがまだない場合は、「[Amazon EC2 入門ガイド](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_GetStarted.html)」で EC2 インスタンスのセットアップ方法を参照してください。
+ EC2 インスタンスはキャッシュと同じ VPC にあり、同じセキュリティグループ設定を持っている必要があります。デフォルトでは、Amazon ElastiCache はデフォルト VPC にキャッシュを作成し、デフォルトのセキュリティグループを使用します。このチュートリアルを進めるには、EC2 インスタンスがデフォルト VPC にあり、デフォルトのセキュリティグループが設定されていることを確認してください。
## Amazon VPC セキュリティグループからキャッシュへのネットワークネットワークアクセスを許可する
ElastiCache のノードベースのクラスターは、Valkey および Redis OSS コマンドにポート 6379 を使用し、ElastiCache サーバーレスはポート 6379 とポート 6380 の両方を使用します。EC2 インスタンスから Valkey または Redis OSS コマンドを正常に接続して実行するには、セキュリティグループがこれらのポートへのアクセスを必要に応じて許可する必要があります。
ElastiCache for Memcached は 11211 ポートと 11212 ポートを使用して Memcached コマンドを受け付けます。EC2 インスタンスから Memcached コマンドを正常に接続して実行するには、セキュリティグループがこれらのポートへのアクセスを許可する必要があります。
1. にサインインAWS Command Line Interfaceし、[Amazon EC2 コンソール](https://console.aws.amazon.com/ec2/)を開きます。
1. ナビゲーションペインで、**[ネットワーク & セキュリティ]** の下にある **[セキュリティグループ]** を選択します。
1. セキュリティグループのリストから、Amazon VPC のセキュリティグループを選択します。ElastiCache 用のセキュリティグループを作成した場合を除き、このセキュリティグループは、「*default*」という名前になります。
1. [インバウンド] タブを開き、[編集] をクリックします。
1. **[編集]** を選択します。
1. **ルールの追加** を選択します。
1. [タイプ] 列で **[カスタム TCP ルール]** を選択します。
1. Valkey または Redis OSS を使用している場合は、**[ポート範囲]** ボックスに `6379` と入力します。
Memcached を使用している場合は、**[ポート範囲]** ボックスに `11211` と入力します。
1. **[送信元]** ボックスで **[任意の場所]** を選択します。ポート範囲が 0.0.0.0/0 になるため、Amazon VPC 内で起動したすべての Amazon EC2 インスタンスをキャッシュに接続できます。
1. ElastiCache サーバーレスを使用している場合は、**[ルールの追加]** を選択して別のルールを追加します。
1. **Type** 列で **Custom TCP rule** を選択します。
1. ElastiCache for Redis OSS を使用している場合は、**[ポート範囲]** ボックスに `6380` と入力します。
ElastiCache for Memcached を使用している場合は、**[ポート範囲]** ボックスに `11212` と入力します。
1. **[送信元]** ボックスで **[任意の場所]** を選択します。ポート範囲が 0.0.0.0/0 になるため、Amazon VPC 内で起動したすべての Amazon EC2 インスタンスをキャッシュに接続できます。
1. **[保存]** を選択します。
## コマンドラインアクセスをダウンロードしてセットアップする
***valkey-cli* ユーティリティをダウンロードしてインストールします。**
ElastiCache for Valkey を使用する場合、valkey-cli ユーティリティが役立ちます。redis-cli で ElastiCache for Redis OSS を使用している場合、valkey-cli に切り替えることを検討してください。valkey-cli は Redis OSS でも機能します。
1. 選択した接続ユーティリティを使用して、Amazon EC2 インスタンスに接続します。Amazon EC2 インスタンスに接続する方法については、「[Amazon EC2 入門ガイド](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_GetStarted.html)」を参照してください。
1. セットアップに適したコマンドを実行し、valkey-cli ユーティリティをダウンロードしてインストールします。
**Amazon Linux 2**
```
sudo amazon-linux-extras install epel -y
sudo yum install gcc jemalloc-devel openssl-devel tcl tcl-devel -y
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 BUILD_TLS=yes
```
**注記**
redis6 パッケージをインストールすると、デフォルトの暗号化サポートで redis6-cli がインストールされます。
valkey-cli または redis-cli をインストールするときは TLS のビルドサポートがあることが重要です。ElastiCache サーバーレスには TLS が有効になっている場合にのみアクセスできます。
接続先のクラスターが暗号化されていない場合、`Build_TLS=yes` オプションは必要ありません。
# Valkey サーバーレスキャッシュの作成
このステップでは、Amazon ElastiCache に新しいキャッシュを作成します。
**AWS マネジメントコンソール**
ElastiCache コンソールを使用して新しいキャッシュを作成するには:
1. AWS マネジメントコンソールにサインインし、[https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/) を開きます。
1. コンソールの左側のナビゲーションペインで、**[Valkey キャッシュ]** を選択します。
1. コンソールの右側で、**[Valkey キャッシュを作成]** を選択します。
1. **[キャッシュ設定]** に **[名前]** を入力します。オプションで、キャッシュの**説明**を入力できます。
1. デフォルトの設定を選択したままにしておきます。
1. **[作成]** をクリックして、キャッシュを作成します。
1. キャッシュが「アクティブ」状態になったら、キャッシュへのデータの書き込みと読み取りを開始できます。
**AWS CLI**
以下の AWS CLI の例では、create-serverless-cache を使用して新しいキャッシュを作成します。
**Linux**
```
aws elasticache create-serverless-cache \
--serverless-cache-name CacheName \
--engine valkey
```
**Windows**
```
aws elasticache create-serverless-cache ^
--serverless-cache-name CacheName ^
--engine valkey
```
[ステータス] フィールドの値が `CREATING` に設定されていることに注意してください。
ElastiCache でキャッシュの作成が終了したか確認するには、`describe-serverless-caches` コマンドを使用します。
**Linux**
```
aws elasticache describe-serverless-caches --serverless-cache-name CacheName
```
**Windows**
```
aws elasticache describe-serverless-caches --serverless-cache-name CacheName
```
新しいキャッシュを作成したら、「[キャッシュへのデータの読み取りと書き込み](GettingStarted.serverless-valkey.step2.md)」に進みます。
# キャッシュへのデータの読み取りと書き込み
このセクションでは、Amazon EC2 インスタンスが作成済みであり、このインスタンスに接続できることを前提としています。これを行う手順については、「[Amazon EC2 入門ガイド](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_GetStarted.html)」を参照してください。
また、このセクションでは、キャッシュに接続する EC2 インスタンスの VPC アクセスとセキュリティグループの設定が完了し、EC2 インスタンスに valkey-cli が設定されていることを前提としています。このステップの詳細については、「[ElastiCache のセットアップ](set-up.md)」を参照してください。
以下のステップに加えて、大規模なアプリケーションやグローバルアプリケーションがある場合は、レプリカを作成してそこから読み取ることで、読み取りパフォーマンスを大幅に向上させることができます。このより高度なステップの詳細については、「[リードレプリカの使用に関するベストプラクティス](ReadReplicas.md)」を参照してください。
**キャッシュエンドポイントを見つける**
**AWS マネジメントコンソール**
ElastiCache コンソールを使用してキャッシュのエンドポイントを見つけるには:
1. にサインインAWS マネジメントコンソールし、[https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/) で Amazon ElastiCache コンソールを開きます。
1. コンソールの左側のナビゲーションペインで、**[Valkey キャッシュ]** を選択します。
1. コンソールの右側で、作成したキャッシュの名前をクリックします。
1. **[キャッシュ詳細]** で、キャッシュエンドポイントを見つけてコピーします。
**AWS CLI**
次のAWS CLI例は、describe-serverless-caches コマンドを使用して新しいキャッシュのエンドポイントを検索する方法を示しています。コマンドを実行したら、「Endpoint」フィールドを探します。
**Linux**
```
aws elasticache describe-serverless-caches \
--serverless-cache-name CacheName
```
**Windows**
```
aws elasticache describe-serverless-caches ^
--serverless-cache-name CacheName
```
## Valkey キャッシュに接続する (Linux)
これで、必要なエンドポイントが手に入ったので、EC2 インスタンスにログインし、キャッシュに接続できます。次の例では、*valkey-cli* ユーティリティを使用して、クラスターに接続します。次のコマンドでキャッシュに接続します (注: cache-endpoint は前のステップで取得したエンドポイントに置き換えてください)。
```
src/valkey-cli -h cache-endpoint --tls -p 6379
set a "hello" // Set key "a" with a string value and no expiration
OK
get a // Get value for key "a"
"hello"
```
## Valkey キャッシュに接続する (Windows)
これで、必要なエンドポイントが手に入ったので、EC2 インスタンスにログインし、キャッシュに接続できます。次の例では、*valkey-cli* ユーティリティを使用して、クラスターに接続します。以下のコマンドでキャッシュに接続します。コマンドプロンプトを開いて Valkey または Redis OSS ディレクトリに移動し、コマンドを実行します (注: Cache\$1Endpoint は前のステップで取得したエンドポイントに置き換えてください)。
```
c:\Valkey>valkey-cli -h Valkey_Cluster_Endpoint --tls -p 6379
set a "hello" // Set key "a" with a string value and no expiration
OK
get a // Get value for key "a"
"hello"
```
これで、「[(オプション) クリーンアップする](GettingStarted.serverless-valkey.step3.md)」に進むことができます。
# (オプション) クリーンアップする
作成した Amazon ElastiCache のキャッシュが不要になった場合は、削除できます。このステップにより、使用していないリソースに対して課金されることがなくなります。ElastiCache コンソール、AWS CLI、または ElastiCache API を使用してキャッシュを削除できます。
**AWS マネジメントコンソール**
コンソールを使用してキャッシュを削除するには:
1. AWS マネジメントコンソールにサインインして、Amazon ElastiCache コンソール ([https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/)) を開きます。
1. コンソールの左側のナビゲーションペインで、**[Valkey キャッシュ]** を選択します。
1. 削除するキャッシュの横にあるボタンを選択します。
1. 右上の **[アクション]** を選択し、**[削除]** を選択します。
1. オプションで、キャッシュを削除する前に最終スナップショットを取ることもできます。
1. **[削除]** 確認画面で、**[削除]** を選択してクラスターを削除するか、**[キャンセル]** を選択してクラスターを保持します。
キャッシュのステータスが **[Deleting]** になると、キャッシュの課金も停止されます。
**AWS CLI**
次の AWS CLI の例では、delete-serverless-cache コマンドを使用してキャッシュを削除します。
**Linux**
```
aws elasticache delete-serverless-cache \
--serverless-cache-name CacheName
```
**Windows**
```
aws elasticache delete-serverless-cache ^
--serverless-cache-name CacheName
```
**[ステータス]** フィールドの値が **[Deleting]** になっていることに注意してください。
これで、「[次のステップ](GettingStarted.serverless-valkey.next-steps.md)」に進むことができます。
# 次のステップ
ElastiCache の詳細については、以下のウェブページを参照してください。
+ [ElastiCache の使用](WorkingWithElastiCache.md)
+ [ElastiCache のスケーリング](Scaling.md)
+ [Amazon ElastiCache でのログ記録とモニタリング](MonitoringECMetrics.md)
+ [ElastiCache のベストプラクティスとキャッシュ戦略](BestPractices.md)
+ [スナップショットおよび復元](backups.md)
+ [Amazon SNS による ElastiCache イベントのモニタリング](ECEvents.md)
# Redis OSS のサーバーレスキャッシュを作成する
このステップでは、Amazon ElastiCache に新しいキャッシュを作成します。
**AWS マネジメントコンソール**
ElastiCache コンソールを使用して新しいキャッシュを作成するには:
1. AWS マネジメントコンソール にサインインして、ElastiCache コンソール ([https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/)) を開きます。
1. コンソールの左側のナビゲーションペインで、**[Redis OSS キャッシュ]** を選択します。
1. コンソールの右側で、**[Redis OSS キャッシュを作成]** を選択します。
1. **[キャッシュ設定]** に **[名前]** を入力します。オプションで、キャッシュの**説明**を入力できます。
1. デフォルトの設定を選択したままにしておきます。
1. **[作成]** をクリックして、キャッシュを作成します。
1. キャッシュが「アクティブ」状態になったら、キャッシュへのデータの書き込みと読み取りを開始できます。
**AWS CLI**
以下の AWS CLI の例では、create-serverless-cache を使用して新しいキャッシュを作成します。
**Linux**
```
aws elasticache create-serverless-cache \
--serverless-cache-name CacheName \
--engine redis
```
**Windows**
```
aws elasticache create-serverless-cache ^
--serverless-cache-name CacheName ^
--engine redis
```
[ステータス] フィールドの値が `CREATING` に設定されていることに注意してください。
ElastiCache でキャッシュの作成が終了したか確認するには、`describe-serverless-caches` コマンドを使用します。
**Linux**
```
aws elasticache describe-serverless-caches --serverless-cache-name CacheName
```
**Windows**
```
aws elasticache describe-serverless-caches --serverless-cache-name CacheName
```
新しいキャッシュを作成したら、「[キャッシュへのデータの読み取りと書き込み](GettingStarted.serverless-redis.step2.md)」に進みます。
# キャッシュへのデータの読み取りと書き込み
このセクションでは、Amazon EC2 インスタンスが作成済みであり、このインスタンスに接続できることを前提としています。これを行う手順については、「[Amazon EC2 入門ガイド](https://aws.amazon.com/ec2/getting-started/)」を参照してください。
また、このセクションでは、キャッシュに接続する EC2 インスタンスの VPC アクセスとセキュリティグループの設定が完了し、EC2 インスタンスに valkey-cli が設定されていることを前提としています。このステップの詳細については、「[ElastiCache のセットアップ](set-up.md)」を参照してください。
**キャッシュエンドポイントを見つける**
**AWS マネジメントコンソール**
ElastiCache コンソールを使用してキャッシュのエンドポイントを見つけるには:
1. にサインインAWS マネジメントコンソールし、[https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/) で Amazon ElastiCache コンソールを開きます。
1. コンソールの左側のナビゲーションペインで、**[Valkey キャッシュ]** または **[Redis OSS キャッシュ]** を選択します。
1. コンソールの右側で、作成したキャッシュの名前をクリックします。
1. **[キャッシュ詳細]** で、キャッシュエンドポイントを見つけてコピーします。
**AWS CLI**
次のAWS CLI例は、describe-serverless-caches コマンドを使用して新しいキャッシュのエンドポイントを検索する方法を示しています。コマンドを実行したら、「Endpoint」フィールドを探します。
**Linux**
```
aws elasticache describe-serverless-caches \
--serverless-cache-name CacheName
```
**Windows**
```
aws elasticache describe-serverless-caches ^
--serverless-cache-name CacheName
```
## Valkey または Redis OSS キャッシュに接続する (Linux)
これで、必要なエンドポイントが手に入ったので、EC2 インスタンスにログインし、キャッシュに接続できます。次の例では、*valkey-cli* ユーティリティを使用して、クラスターに接続します。次のコマンドでキャッシュに接続します (注: cache-endpoint は前のステップで取得したエンドポイントに置き換えてください)。
```
src/valkey-cli -h cache-endpoint --tls -p 6379
set a "hello" // Set key "a" with a string value and no expiration
OK
get a // Get value for key "a"
"hello"
```
## Valkey または Redis OSS キャッシュに接続する (Windows)
これで、必要なエンドポイントが手に入ったので、EC2 インスタンスにログインし、キャッシュに接続できます。次の例では、*valkey-cli* ユーティリティを使用して、クラスターに接続します。以下のコマンドでキャッシュに接続します。コマンドプロンプトを開いて Valkey ディレクトリに移動し、コマンドを実行します (注: Cache\$1Endpoint は前のステップで取得したエンドポイントに置き換えてください)。
```
c:\Redis>valkey-cli -h Redis_Cluster_Endpoint --tls -p 6379
set a "hello" // Set key "a" with a string value and no expiration
OK
get a // Get value for key "a"
"hello"
```
これで、「[(オプション) クリーンアップする](GettingStarted.serverless-redis.step3.md)」に進むことができます。
# (オプション) クリーンアップする
作成した Amazon ElastiCache のキャッシュが不要になった場合は、削除できます。このステップにより、使用していないリソースに対して課金されることがなくなります。ElastiCache コンソール、AWS CLI、または ElastiCache API を使用してキャッシュを削除できます。
**AWS マネジメントコンソール**
コンソールを使用してキャッシュを削除するには:
1. AWS マネジメントコンソールにサインインして、Amazon ElastiCache コンソール ([https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/)) を開きます。
1. コンソールの左側のナビゲーションペインで、**[Valkey キャッシュ] または [Redis OSS キャッシュ]** を選択します。
1. 削除するキャッシュの横にあるボタンを選択します。
1. 右上の **[アクション]** を選択し、**[削除]** を選択します。
1. オプションで、キャッシュを削除する前に最終スナップショットを取ることもできます。
1. **[削除]** 確認画面で、**[削除]** を選択してクラスターを削除するか、**[キャンセル]** を選択してクラスターを保持します。
キャッシュのステータスが **[Deleting]** になると、キャッシュの課金も停止されます。
**AWS CLI**
次の AWS CLI の例では、delete-serverless-cache コマンドを使用してキャッシュを削除します。
**Linux**
```
aws elasticache delete-serverless-cache \
--serverless-cache-name CacheName
```
**Windows**
```
aws elasticache delete-serverless-cache ^
--serverless-cache-name CacheName
```
**[ステータス]** フィールドの値が **[Deleting]** になっていることに注意してください。
これで、「[次のステップ](GettingStarted.serverless-redis.next-steps.md)」に進むことができます。
# 次のステップ
ElastiCache の詳細については、以下のウェブページを参照してください。
+ [ElastiCache の使用](WorkingWithElastiCache.md)
+ [ElastiCache のスケーリング](Scaling.md)
+ [Amazon ElastiCache でのログ記録とモニタリング](MonitoringECMetrics.md)
+ [ElastiCache のベストプラクティスとキャッシュ戦略](BestPractices.md)
+ [スナップショットおよび復元](backups.md)
+ [Amazon SNS による ElastiCache イベントのモニタリング](ECEvents.md)
# Memcached サーバーレスキャッシュを作成する
**AWS マネジメントコンソール**
ElastiCache コンソールを使用して新しい Memcached サーバーレスキャッシュを作成するには:
1. AWS マネジメントコンソール にサインインして、ElastiCache コンソール ([https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/)) を開きます。
1. コンソールの左側のナビゲーションペインで、**[Memcached キャッシュ]** を選択します。
1. コンソールの右側で、**[Memcached キャッシュを作成]** を選択します。
1. **[キャッシュ設定]** に**名前**を入力します。オプションで、キャッシュの**説明**を入力できます。
1. デフォルトの設定を選択したままにしておきます。
1. **[作成]** をクリックして、キャッシュを作成します。
1. キャッシュが「アクティブ」状態になったら、キャッシュへのデータの書き込みと読み取りを開始できます。
AWS CLI を使用して新しいキャッシュを作成するには
以下の AWS CLI の例では、create-serverless-cache を使用して新しいキャッシュを作成します。
**Linux**
```
aws elasticache create-serverless-cache \
--serverless-cache-name CacheName \
--engine memcached
```
**Windows**
```
aws elasticache create-serverless-cache ^
--serverless-cache-name CacheName ^
--engine memcached
```
[ステータス] フィールドの値が `CREATING` に設定されていることに注意してください。
ElastiCache でキャッシュの作成が終了したか確認するには、`describe-serverless-caches` コマンドを使用します。
**Linux**
```
aws elasticache describe-serverless-caches --serverless-cache-name CacheName
```
**Windows**
```
aws elasticache describe-serverless-caches --serverless-cache-name CacheName
```
新しいキャッシュを作成したら、「[キャッシュへのデータの読み取りと書き込み](read-write-cache-mem.md)」に進んでください。
# キャッシュへのデータの読み取りと書き込み
このセクションでは、Amazon EC2 インスタンスが作成済みであり、このインスタンスに接続できることを前提としています。これを行う手順については、「[Amazon EC2 入門ガイド](https://aws.amazon.com/ec2/getting-started/)」を参照してください。
デフォルトで、ElastiCache はデフォルトの VPC でキャッシュを作成します。キャッシュに接続できるように、EC2 インスタンスもデフォルト VPC に作成されていることを確認します。
**キャッシュエンドポイントを検索する**
**AWS マネジメントコンソール**
ElastiCache コンソールを使用してキャッシュのエンドポイントを見つけるには:
1. にサインインAWS マネジメントコンソールし、[https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/) で Amazon ElastiCache コンソールを開きます。
1. コンソールの左側のナビゲーションペインで、**[Memcached キャッシュ]** を選択します。
1. コンソールの右側で、作成したキャッシュの名前をクリックします。
1. **[キャッシュ詳細]** で、キャッシュエンドポイントを見つけてコピーします。
**AWS CLI**
次のAWS CLI例は、describe-serverless-caches コマンドを使用して新しいキャッシュのエンドポイントを検索する方法を示しています。コマンドを実行したら、「Endpoint」フィールドを探します。
**Linux**
```
aws elasticache describe-serverless-caches \
--serverless-cache-name CacheName
```
**Windows**
```
aws elasticache describe-serverless-caches ^
--serverless-cache-name CacheName
```
## OpenSSL を使用して接続する
OpenSSL を使用して接続する方法については、「[ElastiCache の転送時の暗号化 (TLS)](in-transit-encryption.md)」を参照してください
## Memcached Java クライアントを使用して接続する
```
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.FailureMode;
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);
// Set Failure Mode to Retry
connectionFactoryBuilder.setFailureMode(FailureMode.Retry);
MemcachedClient client = new MemcachedClient(connectionFactoryBuilder.build(), AddrUtil.getAddresses("mycluster-fnjyzo.serverless.use1.cache.amazonaws.com:11211"));
// Store a data item for an hour.
client.set("theKey", 3600, "This is the data value");
}
}
```
## Memcached PHP クライアントを使用して接続する
```
addServer($cluster_endpoint, $server_port);
if(!$tls_client->setOption(Memcached::OPT_USE_TLS, 1)) {
echo $tls_client->getLastErrorMessage(), "\n";
exit(1);
}
$tls_config = new MemcachedTLSContextConfig();
$tls_config->hostname = '*.serverless.use1.cache.amazonaws.com';
$tls_config->skip_cert_verify = false;
$tls_config->skip_hostname_verify = false;
$tls_client->createAndSetTLSContext((array)$tls_config);
/* store the data for 60 seconds in the cluster */
$tls_client->set('key', 'value', 60);
?>
```
## Memcached Python クライアント (Pymemcache) を使用して接続する
[https://pymemcache.readthedocs.io/en/latest/getting\$1started.html](https://pymemcache.readthedocs.io/en/latest/getting_started.html) を参照してください
```
import ssl
from pymemcache.client.base import Client
context = ssl.create_default_context()
cluster_endpoint =
target_port = 11211
memcached_client = Client(("{cluster_endpoint}", target_port), tls_context=context)
memcached_client.set("key", "value", expire=500, noreply=False)
assert self.memcached_client.get("key").decode() == "value"
```
## Memcached NodeJS/TS クライアント (Electrode-IO memcache) を使用して接続する
[https://github.com/electrode-io/memcache](https://github.com/electrode-io/memcache) と [https://www.npmjs.com/package/memcache-client](https://www.npmjs.com/package/memcache-client) を参照してください
`npm i memcache-client` を用いたインストール
アプリケーションで、以下のように memcached TLS クライアントを作成します。
```
var memcache = require("memcache-client");
const client = new memcache.MemcacheClient({server: "{cluster_endpoint}:11211", tls: {}});
client.set("key", "value");
```
## Memcached Rust クライアント (rust-memcache) を使用して接続する
[https://crates.io/crates/memcache](https://crates.io/crates/memcache) と [https://github.com/aisk/rust-memcache](https://github.com/aisk/rust-memcache) を参照してください。
```
// create connection with to memcached server node:
let client = memcache::connect("memcache+tls://:11211?verify_mode=none").unwrap();
// set a string value
client.set("foo", "bar", 0).unwrap();
```
## Memcached Go クライアント (Gomemcache) を使用して接続する
[https://github.com/bradfitz/gomemcache ](https://github.com/bradfitz/gomemcache)を参照してください
```
c := New(net.JoinHostPort("{cluster_endpoint}", strconv.Itoa(port)))
c.DialContext = func(ctx context.Context, network, addr string) (net.Conn, error) {
var td tls.Dialer
td.Config = &tls.Config{}
return td.DialContext(ctx, network, addr)
}
foo := &Item{Key: "foo", Value: []byte("fooval"), Flags: 123}
err := c.Set(foo)
```
## Memcached Ruby クライアント (Dalli) を使用して接続する
[https://github.com/petergoldstein/dalli](https://github.com/petergoldstein/dalli) を参照してください
```
require 'dalli'
ssl_context = OpenSSL::SSL::SSLContext.new
ssl_context.ssl_version = :SSLv23
ssl_context.verify_hostname = true
ssl_context.verify_mode = OpenSSL::SSL::VERIFY_PEER
client = Dalli::Client.new(":11211", :ssl_context => ssl_context);
client.get("abc")
```
## Memcached .NET クライアント (EnyimMemcachedCore) を使用して接続する
[https://github.com/cnblogs/EnyimMemcachedCore](https://github.com/cnblogs/EnyimMemcachedCore) を参照してください
```
"MemcachedClient": {
"Servers": [
{
"Address": "{cluster_endpoint}",
"Port": 11211
}
],
"UseSslStream": true
}
```
これで、「[(オプション) クリーンアップする](read-write-cleanup-mem.md)」に進むことができます。
# (オプション) クリーンアップする
**の使用AWS マネジメントコンソール**
次の手順では、デプロイから 1 つのキャッシュを削除します。複数のキャッシュを削除するには、削除するキャッシュごとに同じ手順を繰り返してください。別のキャッシュの削除手順を開始する前に、1 つのキャッシュの削除が終了するのを待つ必要はありません。
**キャッシュを削除するには**
1. にサインインAWS マネジメントコンソールし、[https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/) で Amazon ElastiCache コンソールを開きます。
1. ElastiCache コンソールダッシュボードで、削除するキャッシュで実行されているエンジンを選択します。そのエンジンを実行しているすべてのキャッシュが一覧表示されます。
1. 削除するキャッシュを選択するには、キャッシュのリストからキャッシュの名前を選択します。
**重要**
ElastiCache コンソールから、一度に 1 つずつキャッシュを削除できます。複数のキャッシュを選択すると、削除オペレーションが無効になります。
1. **[アクション]** で、**[削除]** を選択します。
1. **[キャッシュの削除]** 確認画面で、**[削除]** を選択してキャッシュを削除するか、**[キャンセル]** を選択してクラスターを保持します。
1. **[削除]** を選択した場合は、キャッシュのステータスが *[削除中]* に変わります。
キャッシュのステータスが **[Deleting]** になると、キャッシュの課金も停止されます。
**の使用AWS CLI**
次のコードでは、キャッシュ my-cache を削除します。
```
aws elasticache delete-serverless-cache --serverless-cache-name my-cache
```
delete-serverless-cache CLI アクションは、サーバーレスキャッシュを 1 つだけ削除します。複数のキャッシュを削除するには、削除するサーバーレスキャッシュごとに delete-serverless-cache を呼び出します。1 つのサーバーレスキャッシュの削除が終了するまで待たなくても次のサーバーレスキャッシュを削除できます。
**Linux、macOS、Unix の場合**:
```
aws elasticache delete-serverless-cache \
--serverless-cache-name my-cache
```
**Windows の場合:**
```
aws elasticache delete-serverless-cache ^
--serverless-cache-name my-cache
```
詳細については、「 for ElastiCache AWS CLI」トピックdelete-serverless-cache」を参照してください。
これで、「[次のステップ](next-steps-mem.md)」に進むことができます。
# 次のステップ
ElastiCache については、以下を参照してください。
+ [ElastiCache の使用](WorkingWithElastiCache.md)
+ [ElastiCache のスケーリング](Scaling.md)
+ [ElastiCache のクォータ](quota-limits.md)
+ [ElastiCache のベストプラクティスとキャッシュ戦略](BestPractices.md)
+ [ElastiCache イベントの表示](ECEvents.Viewing.md)
# チュートリアル: Python と ElastiCache の開始方法
このセクションには、Valkey と Redis OSS に対応した ElastiCache の学習に役立つ実践的なチュートリアルが含まれています。言語固有のチュートリアルの 1 つを実行することをお勧めします。
**注記**
AWS SDK は、さまざまな言語で利用できます。詳細なリストについては、「[アマゾン ウェブ サービスのツール](https://aws.amazon.com/tools/)」を参照してください。
**Topics**
+ [Python と ElastiCache](ElastiCache-Getting-Started-Tutorials-Python.md)
# Python と ElastiCache
このチュートリアルでは、AWS SDK for Python (Boto3) を使用して、次の ElastiCache オペレーションを実行するシンプルなプログラムを記述します。
+ ElastiCache for Redis OSS クラスターを作成する (クラスターモードが有効およびクラスターモードが無効)
+ ユーザー/ユーザーグループが存在するかどうかを確認し、存在しない場合は作成します (この機能は、Valkey 7.2 以降、および Redis OSS 6.0 から 7.1 で使用できます)
+ ElastiCache に接続する
+ 文字列の設定と取得、ストリームからの読み取りと書き込み、Pub/Sub チャンネルからの公開と登録などのオペレーションを実行します。
このチュートリアルでは、AWS SDK for Python (Boto) のドキュメントを参照できます。以下のセクションは [ElastiCache の低レベルのクライアント](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/elasticache.html) に固有のものです。
## チュートリアルの前提条件
+ AWS SDKs を使用するようにAWSアクセスキーを設定します。詳細については、「[ElastiCache のセットアップ](set-up.md)」を参照してください。
+ Python 3.0 以降をインストールします。詳細については、[https://www.python.org/downloads](https://www.python.org/downloads) を参照してください。手順については、Boto 3 ドキュメントの「[クイックスタート](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/quickstart.html)」を参照してください。
**Topics**
+ [チュートリアルの前提条件](#ElastiCache-Getting-Started-Tutorials-Prerquisites)
+ [チュートリアル: ElastiCache クラスターとユーザーの作成](#ElastiCache-Getting-Started-Tutorials-Create-Cluster-and-Users)
+ [チュートリアル: ElastiCache への接続](#ElastiCache-Getting-Started-Tutorials-Connecting)
+ [使用例](#ElastiCache-Getting-Started-Tutorials-Usage)
## チュートリアル: ElastiCache クラスターとユーザーの作成
次の例では、ElastiCache for Redis OSS 管理オペレーション (クラスターまたはユーザーの作成) で boto3 SDK を使用し、データ処理で redis-py/redis-py-cluster を使用します。
**Topics**
+ [クラスタモードが無効のクラスターを作成する](#ElastiCache-Getting-Started-Tutorials-Create-Cluster)
+ [TLS と RBAC を用いてクラスターモードが無効のクラスターを作成する](#ElastiCache-Getting-Started-Tutorials-RBAC)
+ [クラスタモードが有効のクラスターの作成](#ElastiCache-Getting-Started-Tutorials-Cluster-Enabled)
+ [TLS および RBAC を用いたクラスターモードが有効のクラスターの作成](#ElastiCache-Getting-Started-Tutorials-Cluster-RBAC)
+ [ユーザー/ユーザーグループが存在するかどうかを確認し、そうでない場合は作成する](#ElastiCache-Getting-Started-Tutorials-Users)
### クラスタモードが無効のクラスターを作成する
次のプログラムを *CreateClusterModeDisabledCluster.py* というファイルにコピーアンドペーストします。
```
import boto3
import logging
logging.basicConfig(level=logging.INFO)
client = boto3.client('elasticache')
def create_cluster_mode_disabled(CacheNodeType='cache.t3.small',EngineVersion='6.0',NumCacheClusters=2,ReplicationGroupDescription='Sample cluster',ReplicationGroupId=None):
"""Creates an ElastiCache Cluster with cluster mode disabled
Returns a dictionary with the API response
:param CacheNodeType: Node type used on the cluster. If not specified, cache.t3.small will be used
Refer to https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/CacheNodes.SupportedTypes.html for supported node types
:param EngineVersion: Engine version to be used. If not specified, latest will be used.
:param NumCacheClusters: Number of nodes in the cluster. Minimum 1 (just a primary node) and maximun 6 (1 primary and 5 replicas).
If not specified, cluster will be created with 1 primary and 1 replica.
:param ReplicationGroupDescription: Description for the cluster.
:param ReplicationGroupId: Name for the cluster
:return: dictionary with the API results
"""
if not ReplicationGroupId:
return 'ReplicationGroupId parameter is required'
response = client.create_replication_group(
AutomaticFailoverEnabled=True,
CacheNodeType=CacheNodeType,
Engine='valkey',
EngineVersion=EngineVersion,
NumCacheClusters=NumCacheClusters,
ReplicationGroupDescription=ReplicationGroupDescription,
ReplicationGroupId=ReplicationGroupId,
SnapshotRetentionLimit=30,
)
return response
if __name__ == '__main__':
# Creates an ElastiCache Cluster mode disabled cluster, based on cache.m6g.large nodes, Valkey 8.0, one primary and two replicas
elasticacheResponse = create_cluster_mode_disabled(
#CacheNodeType='cache.m6g.large',
EngineVersion='8.0',
NumCacheClusters=3,
ReplicationGroupDescription='Valkey cluster mode disabled with replicas',
ReplicationGroupId='valkey202104053'
)
logging.info(elasticacheResponse)
```
このプログラムを実行するには、次のコマンドを入力します。
`python CreateClusterModeDisabledCluster.py`
詳細については、「[ElastiCache でのクラスターの管理](Clusters.md)」を参照してください。
### TLS と RBAC を用いてクラスターモードが無効のクラスターを作成する
セキュリティを確保するために、クラスタモードが無効のクラスターを作成するときに、Transport Layer Security (TLS) とロールベースのアクセスコントロール (RBAC) を使用できます。Valkey または Redis OSS AUTH では、トークンが認証されていれば認証済みのすべてのクライアントにレプリケーショングループへのフルアクセスが認められますが、RBAC はこれとは異なり、クラスターへのアクセスをユーザーグループを介して制御できます。これらのユーザーグループは、レプリケーショングループへのアクセスを分類する方法として設計されています。詳細については、「[ロールベースのアクセスコントロール (RBAC)](Clusters.RBAC.md)」を参照してください。
次のプログラムを *ClusterModeDisabledWithRBAC.py* というファイルにコピーアンドペーストします。
```
import boto3
import logging
logging.basicConfig(level=logging.INFO)
client = boto3.client('elasticache')
def create_cluster_mode_disabled_rbac(CacheNodeType='cache.t3.small',EngineVersion='6.0',NumCacheClusters=2,ReplicationGroupDescription='Sample cluster',ReplicationGroupId=None, UserGroupIds=None, SecurityGroupIds=None,CacheSubnetGroupName=None):
"""Creates an ElastiCache Cluster with cluster mode disabled and RBAC
Returns a dictionary with the API response
:param CacheNodeType: Node type used on the cluster. If not specified, cache.t3.small will be used
Refer to https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/CacheNodes.SupportedTypes.html for supported node types
:param EngineVersion: Engine version to be used. If not specified, latest will be used.
:param NumCacheClusters: Number of nodes in the cluster. Minimum 1 (just a primary node) and maximun 6 (1 primary and 5 replicas).
If not specified, cluster will be created with 1 primary and 1 replica.
:param ReplicationGroupDescription: Description for the cluster.
:param ReplicationGroupId: Mandatory name for the cluster.
:param UserGroupIds: The ID of the user group to be assigned to the cluster.
:param SecurityGroupIds: List of security groups to be assigned. If not defined, default will be used
:param CacheSubnetGroupName: subnet group where the cluster will be placed. If not defined, default will be used.
:return: dictionary with the API results
"""
if not ReplicationGroupId:
return {'Error': 'ReplicationGroupId parameter is required'}
elif not isinstance(UserGroupIds,(list)):
return {'Error': 'UserGroupIds parameter is required and must be a list'}
params={'AutomaticFailoverEnabled': True,
'CacheNodeType': CacheNodeType,
'Engine': 'valkey',
'EngineVersion': EngineVersion,
'NumCacheClusters': NumCacheClusters,
'ReplicationGroupDescription': ReplicationGroupDescription,
'ReplicationGroupId': ReplicationGroupId,
'SnapshotRetentionLimit': 30,
'TransitEncryptionEnabled': True,
'UserGroupIds':UserGroupIds
}
# defaults will be used if CacheSubnetGroupName or SecurityGroups are not explicit.
if isinstance(SecurityGroupIds,(list)):
params.update({'SecurityGroupIds':SecurityGroupIds})
if CacheSubnetGroupName:
params.update({'CacheSubnetGroupName':CacheSubnetGroupName})
response = client.create_replication_group(**params)
return response
if __name__ == '__main__':
# Creates an ElastiCache Cluster mode disabled cluster, based on cache.m6g.large nodes, Valkey 8.0, one primary and two replicas.
# Assigns the existent user group "mygroup" for RBAC authentication
response=create_cluster_mode_disabled_rbac(
CacheNodeType='cache.m6g.large',
EngineVersion='8.0',
NumCacheClusters=3,
ReplicationGroupDescription='Valkey cluster mode disabled with replicas',
ReplicationGroupId='valkey202104',
UserGroupIds=[
'mygroup'
],
SecurityGroupIds=[
'sg-7cc73803'
],
CacheSubnetGroupName='default'
)
logging.info(response)
```
このプログラムを実行するには、次のコマンドを入力します。
`python ClusterModeDisabledWithRBAC.py`
詳細については、「[ElastiCache でのクラスターの管理](Clusters.md)」を参照してください。
### クラスタモードが有効のクラスターの作成
次のプログラムを *ClusterModeEnabled.py* というファイルにコピーアンドペーストします。
```
import boto3
import logging
logging.basicConfig(level=logging.INFO)
client = boto3.client('elasticache')
def create_cluster_mode_enabled(CacheNodeType='cache.t3.small',EngineVersion='6.0',NumNodeGroups=1,ReplicasPerNodeGroup=1, ReplicationGroupDescription='Sample cache with cluster mode enabled',ReplicationGroupId=None):
"""Creates an ElastiCache Cluster with cluster mode enabled
Returns a dictionary with the API response
:param CacheNodeType: Node type used on the cluster. If not specified, cache.t3.small will be used
Refer to https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/CacheNodes.SupportedTypes.html for supported node types
:param EngineVersion: Engine version to be used. If not specified, latest will be used.
:param NumNodeGroups: Number of shards in the cluster. Minimum 1 and maximun 90.
If not specified, cluster will be created with 1 shard.
:param ReplicasPerNodeGroup: Number of replicas per shard. If not specified 1 replica per shard will be created.
:param ReplicationGroupDescription: Description for the cluster.
:param ReplicationGroupId: Name for the cluster
:return: dictionary with the API results
"""
if not ReplicationGroupId:
return 'ReplicationGroupId parameter is required'
response = client.create_replication_group(
AutomaticFailoverEnabled=True,
CacheNodeType=CacheNodeType,
Engine='valkey',
EngineVersion=EngineVersion,
ReplicationGroupDescription=ReplicationGroupDescription,
ReplicationGroupId=ReplicationGroupId,
# Creates a cluster mode enabled cluster with 1 shard(NumNodeGroups), 1 primary node (implicit) and 2 replicas (replicasPerNodeGroup)
NumNodeGroups=NumNodeGroups,
ReplicasPerNodeGroup=ReplicasPerNodeGroup,
CacheParameterGroupName='default.valkey7.2.cluster.on'
)
return response
# Creates a cluster mode enabled
response = create_cluster_mode_enabled(
CacheNodeType='cache.m6g.large',
EngineVersion='6.0',
ReplicationGroupDescription='Valkey cluster mode enabled with replicas',
ReplicationGroupId='valkey20210',
# Creates a cluster mode enabled cluster with 1 shard(NumNodeGroups), 1 primary (implicit) and 2 replicas (replicasPerNodeGroup)
NumNodeGroups=2,
ReplicasPerNodeGroup=1,
)
logging.info(response)
```
このプログラムを実行するには、次のコマンドを入力します。
`python ClusterModeEnabled.py`
詳細については、「[ElastiCache でのクラスターの管理](Clusters.md)」を参照してください。
### TLS および RBAC を用いたクラスターモードが有効のクラスターの作成
セキュリティを確保するために、クラスタモードが有効のクラスターを作成するときに、Transport Layer Security (TLS) とロールベースのアクセスコントロール (RBAC) を使用できます。Valkey または Redis OSS AUTH では、トークンが認証されていれば認証済みのすべてのクライアントにレプリケーショングループへのフルアクセスが認められますが、RBAC はこれとは異なり、クラスターへのアクセスをユーザーグループを介して制御できます。これらのユーザーグループは、レプリケーショングループへのアクセスを分類する方法として設計されています。詳細については、「[ロールベースのアクセスコントロール (RBAC)](Clusters.RBAC.md)」を参照してください。
次のプログラムを *ClusterModeEnabledWithRBAC.py* というファイルにコピーアンドペーストします。
```
import boto3
import logging
logging.basicConfig(level=logging.INFO)
client = boto3.client('elasticache')
def create_cluster_mode_enabled(CacheNodeType='cache.t3.small',EngineVersion='6.0',NumNodeGroups=1,ReplicasPerNodeGroup=1, ReplicationGroupDescription='Sample cache with cluster mode enabled',ReplicationGroupId=None,UserGroupIds=None, SecurityGroupIds=None,CacheSubnetGroupName=None,CacheParameterGroupName='default.valkey7.2.cluster.on'):
"""Creates an ElastiCache Cluster with cluster mode enabled and RBAC
Returns a dictionary with the API response
:param CacheNodeType: Node type used on the cluster. If not specified, cache.t3.small will be used
Refer to https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/CacheNodes.SupportedTypes.html for supported node types
:param EngineVersion: Engine version to be used. If not specified, latest will be used.
:param NumNodeGroups: Number of shards in the cluster. Minimum 1 and maximun 90.
If not specified, cluster will be created with 1 shard.
:param ReplicasPerNodeGroup: Number of replicas per shard. If not specified 1 replica per shard will be created.
:param ReplicationGroupDescription: Description for the cluster.
:param ReplicationGroupId: Name for the cluster.
:param CacheParameterGroupName: Parameter group to be used. Must be compatible with the engine version and cluster mode enabled.
:return: dictionary with the API results
"""
if not ReplicationGroupId:
return 'ReplicationGroupId parameter is required'
elif not isinstance(UserGroupIds,(list)):
return {'Error': 'UserGroupIds parameter is required and must be a list'}
params={'AutomaticFailoverEnabled': True,
'CacheNodeType': CacheNodeType,
'Engine': 'valkey',
'EngineVersion': EngineVersion,
'ReplicationGroupDescription': ReplicationGroupDescription,
'ReplicationGroupId': ReplicationGroupId,
'SnapshotRetentionLimit': 30,
'TransitEncryptionEnabled': True,
'UserGroupIds':UserGroupIds,
'NumNodeGroups': NumNodeGroups,
'ReplicasPerNodeGroup': ReplicasPerNodeGroup,
'CacheParameterGroupName': CacheParameterGroupName
}
# defaults will be used if CacheSubnetGroupName or SecurityGroups are not explicit.
if isinstance(SecurityGroupIds,(list)):
params.update({'SecurityGroupIds':SecurityGroupIds})
if CacheSubnetGroupName:
params.update({'CacheSubnetGroupName':CacheSubnetGroupName})
response = client.create_replication_group(**params)
return response
if __name__ == '__main__':
# Creates a cluster mode enabled cluster
response = create_cluster_mode_enabled(
CacheNodeType='cache.m6g.large',
EngineVersion='7.2',
ReplicationGroupDescription='Valkey cluster mode enabled with replicas',
ReplicationGroupId='valkey2021',
# Creates a cluster mode enabled cluster with 1 shard(NumNodeGroups), 1 primary (implicit) and 2 replicas (replicasPerNodeGroup)
NumNodeGroups=2,
ReplicasPerNodeGroup=1,
UserGroupIds=[
'mygroup'
],
SecurityGroupIds=[
'sg-7cc73803'
],
CacheSubnetGroupName='default'
)
logging.info(response)
```
このプログラムを実行するには、次のコマンドを入力します。
`python ClusterModeEnabledWithRBAC.py`
詳細については、「[ElastiCache でのクラスターの管理](Clusters.md)」を参照してください。
### ユーザー/ユーザーグループが存在するかどうかを確認し、そうでない場合は作成する
RBAC では、ユーザーを作成し、アクセス文字列を使用して特定のアクセス許可を割り当てます。特定の役割 (管理者、人事) に調整されたユーザーグループにユーザーを割り当て、その後、それらは 1 つ以上の ElastiCache for Redis OSS レプリケーショングループにデプロイされます。これにより、同じ Valkey または Redis OSS レプリケーショングループを使用するクライアント間にセキュリティ境界を設定し、クライアントが互いのデータにアクセスできないようにすることができます。詳細については、「[ロールベースのアクセスコントロール (RBAC)](Clusters.RBAC.md)」を参照してください。
次のプログラムを *UserAndUserGroups.py* というファイルにコピーアンドペーストします。認証情報を提供するメカニズムを更新します。この例の認証情報は交換可能と表示され、宣言されていない項目が割り当てられています。認証情報をハードコーディングすることは避けてください。
この例では、ユーザーのアクセス許可を持つアクセス文字列を使用します。アクセス文字列の詳細については、「[アクセス文字列を使用したアクセス許可の指定](Clusters.RBAC.md#Access-string)」を参照してください。
```
import boto3
import logging
logging.basicConfig(level=logging.INFO)
client = boto3.client('elasticache')
def check_user_exists(UserId):
"""Checks if UserId exists
Returns True if UserId exists, otherwise False
:param UserId: ElastiCache User ID
:return: True|False
"""
try:
response = client.describe_users(
UserId=UserId,
)
if response['Users'][0]['UserId'].lower() == UserId.lower():
return True
except Exception as e:
if e.response['Error']['Code'] == 'UserNotFound':
logging.info(e.response['Error'])
return False
else:
raise
def check_group_exists(UserGroupId):
"""Checks if UserGroupID exists
Returns True if Group ID exists, otherwise False
:param UserGroupId: ElastiCache User ID
:return: True|False
"""
try:
response = client.describe_user_groups(
UserGroupId=UserGroupId
)
if response['UserGroups'][0]['UserGroupId'].lower() == UserGroupId.lower():
return True
except Exception as e:
if e.response['Error']['Code'] == 'UserGroupNotFound':
logging.info(e.response['Error'])
return False
else:
raise
def create_user(UserId=None,UserName=None,Password=None,AccessString=None):
"""Creates a new user
Returns the ARN for the newly created user or the error message
:param UserId: ElastiCache user ID. User IDs must be unique
:param UserName: ElastiCache user name. ElastiCache allows multiple users with the same name as long as the associated user ID is unique.
:param Password: Password for user. Must have at least 16 chars.
:param AccessString: Access string with the permissions for the user.
:return: user ARN
"""
try:
response = client.create_user(
UserId=UserId,
UserName=UserName,
Engine='Redis',
Passwords=[Password],
AccessString=AccessString,
NoPasswordRequired=False
)
return response['ARN']
except Exception as e:
logging.info(e.response['Error'])
return e.response['Error']
def create_group(UserGroupId=None, UserIds=None):
"""Creates a new group.
A default user is required (mandatory) and should be specified in the UserIds list
Return: Group ARN
:param UserIds: List with user IDs to be associated with the new group. A default user is required
:param UserGroupId: The ID (name) for the group
:return: Group ARN
"""
try:
response = client.create_user_group(
UserGroupId=UserGroupId,
Engine='Redis',
UserIds=UserIds
)
return response['ARN']
except Exception as e:
logging.info(e.response['Error'])
if __name__ == '__main__':
groupName='mygroup2'
userName = 'myuser2'
userId=groupName+'-'+userName
# Creates a new user if the user ID does not exist.
for tmpUserId,tmpUserName in [ (userId,userName), (groupName+'-default','default')]:
if not check_user_exists(tmpUserId):
response=create_user(UserId=tmpUserId, UserName=EXAMPLE,Password=EXAMPLE,AccessString='on ~* +@all')
logging.info(response)
# assigns the new user ID to the user group
if not check_group_exists(groupName):
UserIds = [ userId , groupName+'-default']
response=create_group(UserGroupId=groupName,UserIds=UserIds)
logging.info(response)
```
このプログラムを実行するには、次のコマンドを入力します。
`python UserAndUserGroups.py`
## チュートリアル: ElastiCache への接続
次の例では、Valkey または Redis OSS クライアントを使用して ElastiCache に接続します。
**Topics**
+ [クラスタモードが無効のクラスターへの接続](#ElastiCache-Getting-Started-Tutorials-Connecting-cluster-mode-disabled)
+ [クラスタモードが有効のクラスターへの接続](#ElastiCache-Getting-Started-Tutorials-Connecting-cluster-mode-enabled)
### クラスタモードが無効のクラスターへの接続
次のプログラムを *ConnectClusterModeDisabled.py* というファイルにコピーアンドペーストします。認証情報を提供するメカニズムを更新します。この例の認証情報は交換可能と表示され、宣言されていない項目が割り当てられています。認証情報をハードコーディングすることは避けてください。
```
from redis import Redis
import logging
logging.basicConfig(level=logging.INFO)
redis = Redis(host='primary.xxx.yyyyyy.zzz1.cache.amazonaws.com', port=6379, decode_responses=True, ssl=True, username=example, password=EXAMPLE)
if redis.ping():
logging.info("Connected to Redis")
```
このプログラムを実行するには、次のコマンドを入力します。
`python ConnectClusterModeDisabled.py`
### クラスタモードが有効のクラスターへの接続
次のプログラムを *ConnectClusterModeEnabled.py* というファイルにコピーアンドペーストします。
```
from rediscluster import RedisCluster
import logging
logging.basicConfig(level=logging.INFO)
redis = RedisCluster(startup_nodes=[{"host": "xxx.yyy.clustercfg.zzz1.cache.amazonaws.com","port": "6379"}], decode_responses=True,skip_full_coverage_check=True)
if redis.ping():
logging.info("Connected to Redis")
```
このプログラムを実行するには、次のコマンドを入力します。
`python ConnectClusterModeEnabled.py`
## 使用例
次の例では、ElastiCache 用の boto3 SDK を使用して ElastiCache for Redis OSS を操作します。
**Topics**
+ [文字列の設定と取得](#ElastiCache-Getting-Started-Tutorials-set-strings)
+ [複数の項目があるハッシュを設定して取得する](#ElastiCache-Getting-Started-Tutorials-set-hash)
+ [Pub/Sub チャンネルから公開 (書き込み) および登録 (読み取り) する](#ElastiCache-Getting-Started-Tutorials-pub-sub)
+ [ストリームからの書き込みおよび読み取り](#ElastiCache-Getting-Started-Tutorials-read-write-stream)
### 文字列の設定と取得
次のプログラムを *SetAndGetStrings.py* というファイルにコピーアンドペーストします。
```
import time
import logging
logging.basicConfig(level=logging.INFO,format='%(asctime)s: %(message)s')
keyName='mykey'
currTime=time.ctime(time.time())
# Set the key 'mykey' with the current date and time as value.
# The Key will expire and removed from cache in 60 seconds.
redis.set(keyName, currTime, ex=60)
# Sleep just for better illustration of TTL (expiration) value
time.sleep(5)
# Retrieve the key value and current TTL
keyValue=redis.get(keyName)
keyTTL=redis.ttl(keyName)
logging.info("Key {} was set at {} and has {} seconds until expired".format(keyName, keyValue, keyTTL))
```
このプログラムを実行するには、次のコマンドを入力します。
`python SetAndGetStrings.py`
### 複数の項目があるハッシュを設定して取得する
次のプログラムを *SetAndGetHash.py* というファイルにコピーアンドペーストします。
```
import logging
import time
logging.basicConfig(level=logging.INFO,format='%(asctime)s: %(message)s')
keyName='mykey'
keyValues={'datetime': time.ctime(time.time()), 'epochtime': time.time()}
# Set the hash 'mykey' with the current date and time in human readable format (datetime field) and epoch number (epochtime field).
redis.hset(keyName, mapping=keyValues)
# Set the key to expire and removed from cache in 60 seconds.
redis.expire(keyName, 60)
# Sleep just for better illustration of TTL (expiration) value
time.sleep(5)
# Retrieves all the fields and current TTL
keyValues=redis.hgetall(keyName)
keyTTL=redis.ttl(keyName)
logging.info("Key {} was set at {} and has {} seconds until expired".format(keyName, keyValues, keyTTL))
```
このプログラムを実行するには、次のコマンドを入力します。
`python SetAndGetHash.py`
### Pub/Sub チャンネルから公開 (書き込み) および登録 (読み取り) する
次のプログラムを *PubAndSub.py* というファイルにコピーアンドペーストします。
```
import logging
import time
def handlerFunction(message):
"""Prints message got from PubSub channel to the log output
Return None
:param message: message to log
"""
logging.info(message)
logging.basicConfig(level=logging.INFO)
redis = Redis(host="redis202104053.tihewd.ng.0001.use1.cache.amazonaws.com", port=6379, decode_responses=True)
# Creates the subscriber connection on "mychannel"
subscriber = redis.pubsub()
subscriber.subscribe(**{'mychannel': handlerFunction})
# Creates a new thread to watch for messages while the main process continues with its routines
thread = subscriber.run_in_thread(sleep_time=0.01)
# Creates publisher connection on "mychannel"
redis.publish('mychannel', 'My message')
# Publishes several messages. Subscriber thread will read and print on log.
while True:
redis.publish('mychannel',time.ctime(time.time()))
time.sleep(1)
```
このプログラムを実行するには、次のコマンドを入力します。
`python PubAndSub.py`
### ストリームからの書き込みおよび読み取り
次のプログラムを *ReadWriteStream.py* というファイルにコピーアンドペーストします。
```
from redis import Redis
import redis.exceptions as exceptions
import logging
import time
import threading
logging.basicConfig(level=logging.INFO)
def writeMessage(streamName):
"""Starts a loop writting the current time and thread name to 'streamName'
:param streamName: Stream (key) name to write messages.
"""
fieldsDict={'writerId':threading.currentThread().getName(),'myvalue':None}
while True:
fieldsDict['myvalue'] = time.ctime(time.time())
redis.xadd(streamName,fieldsDict)
time.sleep(1)
def readMessage(groupName=None,streamName=None):
"""Starts a loop reading from 'streamName'
Multiple threads will read from the same stream consumer group. Consumer group is used to coordinate data distribution.
Once a thread acknowleges the message, it won't be provided again. If message wasn't acknowledged, it can be served to another thread.
:param groupName: stream group were multiple threads will read.
:param streamName: Stream (key) name where messages will be read.
"""
readerID=threading.currentThread().getName()
while True:
try:
# Check if the stream has any message
if redis.xlen(streamName)>0:
# Check if if the messages are new (not acknowledged) or not (already processed)
streamData=redis.xreadgroup(groupName,readerID,{streamName:'>'},count=1)
if len(streamData) > 0:
msgId,message = streamData[0][1][0]
logging.info("{}: Got {} from ID {}".format(readerID,message,msgId))
#Do some processing here. If the message has been processed sucessfuly, acknowledge it and (optional) delete the message.
redis.xack(streamName,groupName,msgId)
logging.info("Stream message ID {} read and processed successfuly by {}".format(msgId,readerID))
redis.xdel(streamName,msgId)
else:
pass
except:
raise
time.sleep(0.5)
# Creates the stream 'mystream' and consumer group 'myworkergroup' where multiple threads will write/read.
try:
redis.xgroup_create('mystream','myworkergroup',mkstream=True)
except exceptions.ResponseError as e:
logging.info("Consumer group already exists. Will continue despite the error: {}".format(e))
except:
raise
# Starts 5 writer threads.
for writer_no in range(5):
writerThread = threading.Thread(target=writeMessage, name='writer-'+str(writer_no), args=('mystream',),daemon=True)
writerThread.start()
# Starts 10 reader threads
for reader_no in range(10):
readerThread = threading.Thread(target=readMessage, name='reader-'+str(reader_no), args=('myworkergroup','mystream',),daemon=True)
readerThread.daemon = True
readerThread.start()
# Keep the code running for 30 seconds
time.sleep(30)
```
このプログラムを実行するには、次のコマンドを入力します。
`python ReadWriteStream.py`
# チュートリアル: VPC 内で ElastiCache にアクセスするための Lambda の設定
このチュートリアルでは、ElastiCache サーバーレスキャッシュの作成、Lambda 関数の作成、Lambda 関数のテスト、オプションのクリーンアップ方法について説明します。
**Topics**
+ [ステップ 1: ElastiCache サーバーレスキャッシュを作成する。](#LambdaRedis.step1)
+ [ステップ 2: ElastiCache 用の Lambda 関数を作成する](#LambdaRedis.step2)
+ [ステップ 3: ElastiCache で Lambda 関数をテストする](#LambdaRedis.step3)
+ [ステップ 4: クリーンアップする (オプション)](#LambdaRedis.step4)
## ステップ 1: ElastiCache サーバーレスキャッシュを作成する。
新しいサーバーレスキャッシュを作成するには、次の手順に従います。
### ステップ 1.1: サーバーレスキャッシュを作成する
このステップでは、AWS Command Line Interface(CLI) を使用して、アカウントの us-east-1 リージョンのデフォルトの Amazon VPC にサーバーレスキャッシュを作成します。ElastiCache コンソールまたは API を使用してサーバーレスキャッシュを作成する方法については、「[Redis OSS のサーバーレスキャッシュを作成する](GettingStarted.serverless-redis.step1.md)」を参照してください。
```
aws elasticache create-serverless-cache \
--serverless-cache-name cache-01 \
--description "ElastiCache IAM auth application" \
--engine valkey
```
[ステータス] フィールドの値が `CREATING` に設定されていることに注意してください。ElastiCache がキャッシュの作成を完了するまで、1 分かかる場合があります。
### ステップ 1.2: サーバーレスキャッシュエンドポイントをコピーする
`describe-serverless-caches` コマンドを使用して、ElastiCache for Redis OSS でキャッシュの作成が終了したことを確認します。
```
aws elasticache describe-serverless-caches \
--serverless-cache-name cache-01
```
出力に表示されたエンドポイントアドレスをコピーします。Lambda 関数のデプロイパッケージを作成するときに、このアドレスが必要になります。
### ステップ 1.3: IAM ロールを作成する
1. アカウントが新しいロールを引き継ぐことを許可するロール用の IAM 信頼ポリシードキュメントを以下に示すように作成します。ポリシーを *trust-policy.json* というファイルに保存します。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Effect": "Allow",
"Action": "sts:AssumeRole",
"Resource": "arn:aws:iam::*:role/*"
},
{
"Effect": "Allow",
"Action": "sts:AssumeRole",
"Resource": "arn:aws:iam::*:role/*"
}]
}
```
------
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.4: デフォルトユーザーを作成する
1. 新しいデフォルトユーザーを作成します。
```
aws elasticache create-user \
--user-name default \
--user-id default-user-disabled \
--engine redis \
--authentication-mode Type=no-password-required \
--access-string "off +get ~keys*"
```
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-user-disabled iam-user-01
aws elasticache modify-serverless-cache \
--serverless-cache-name cache-01 \
--user-group-id iam-user-group-01
```
## ステップ 2: ElastiCache 用の Lambda 関数を作成する
ElastiCache キャッシュにアクセスするための Lambda 関数を作成するには、以下の手順に従います。
### ステップ 2.1: Lambda 関数を作成する
このチュートリアルでは、Lambda 関数のコード例を Python で示します。
**Python**
次の Python のコード例では、ElastiCache キャッシュに対して項目の読み取り/書き込みを行います。コードを `app.py` という名前のファイルに保存します。コード内の `elasticache_endpoint` 値を、前のステップでコピーしたエンドポイントアドレスに必ず置き換えてください。
```
from typing import Tuple, Union
from urllib.parse import ParseResult, urlencode, urlunparse
import botocore.session
import redis
from botocore.model import ServiceId
from botocore.signers import RequestSigner
from cachetools import TTLCache, cached
import uuid
class ElastiCacheIAMProvider(redis.CredentialProvider):
def __init__(self, user, cache_name, is_serverless=False, region="us-east-1"):
self.user = user
self.cache_name = cache_name
self.is_serverless = is_serverless
self.region = region
session = botocore.session.get_session()
self.request_signer = RequestSigner(
ServiceId("elasticache"),
self.region,
"elasticache",
"v4",
session.get_credentials(),
session.get_component("event_emitter"),
)
# Generated IAM tokens are valid for 15 minutes
@cached(cache=TTLCache(maxsize=128, ttl=900))
def get_credentials(self) -> Union[Tuple[str], Tuple[str, str]]:
query_params = {"Action": "connect", "User": self.user}
if self.is_serverless:
query_params["ResourceType"] = "ServerlessCache"
url = urlunparse(
ParseResult(
scheme="https",
netloc=self.cache_name,
path="/",
query=urlencode(query_params),
params="",
fragment="",
)
)
signed_url = self.request_signer.generate_presigned_url(
{"method": "GET", "url": url, "body": {}, "headers": {}, "context": {}},
operation_name="connect",
expires_in=900,
region_name=self.region,
)
# RequestSigner only seems to work if the URL has a protocol, but
# Elasticache only accepts the URL without a protocol
# So strip it off the signed URL before returning
return (self.user, signed_url.removeprefix("https://"))
def lambda_handler(event, context):
username = "iam-user-01" # replace with your user id
cache_name = "cache-01" # replace with your cache name
elasticache_endpoint = "cache-01-xxxxx.serverless.use1.cache.amazonaws.com" # replace with your cache endpoint
creds_provider = ElastiCacheIAMProvider(user=username, cache_name=cache_name, is_serverless=True)
redis_client = redis.Redis(host=elasticache_endpoint, port=6379, credential_provider=creds_provider, ssl=True, ssl_cert_reqs="none")
key='uuid'
# create a random UUID - this will be the sample element we add to the cache
uuid_in = uuid.uuid4().hex
redis_client.set(key, uuid_in)
result = redis_client.get(key)
decoded_result = result.decode("utf-8")
# check the retrieved item matches the item added to the cache and print
# the results
if decoded_result == uuid_in:
print(f"Success: Inserted {uuid_in}. Fetched {decoded_result} from Valkey.")
else:
raise Exception(f"Bad value retrieved. Expected {uuid_in}, got {decoded_result}")
return "Fetched value from Valkey"
```
このコードでは、Python redis-py ライブラリを使用して項目をキャッシュに格納し、取得します。このコードでは、cachetools を使用して、生成された IAM 認証トークンを 15 分間キャッシュします。redis-py と cachetools を含むデプロイパッケージを作成するには、次のステップを実行します。
app.py ソースコードファイルを含むプロジェクトディレクトリに、redis-py と cachetools ライブラリをインストールするフォルダパッケージを作成します。
```
mkdir package
```
pip を使用して redis-py、cachetools をインストールします。
```
pip install --target ./package redis
pip install --target ./package cachetools
```
redis-py ライブラリと cachetools ライブラリを含む .zip ファイルを作成します。Linux および macOS では、次のコマンドを実行します。Windows では、任意の zip ユーティリティを使用して、redis-py ライブラリと cachetools ライブラリをルートに置く .zip ファイルを作成します。
```
cd package
zip -r ../my_deployment_package.zip .
```
.zip ファイルに関数コードを追加します。Linux および macOS では、次のコマンドを実行します。Windows では、任意の zip ユーティリティを使用して .zip ファイルのルートに app.py を追加します。
```
cd ..
zip my_deployment_package.zip app.py
```
### ステップ 2.2: IAM ロール (実行ロール) を作成する
という名前の管理AWSポリシーをロール`AWSLambdaVPCAccessExecutionRole`にアタッチします。
```
aws iam attach-role-policy \
--role-name "elasticache-iam-auth-app" \
--policy-arn "arn:aws:iam::aws:policy/service-role/AWSLambdaVPCAccessExecutionRole"
```
### ステップ 2.3: デプロイパッケージをアップロードする (Lambda 関数を作成する)
このステップでは、create-function AWS CLIコマンドを使用して Lambda 関数 (AccessValkey) を作成します。
デプロイパッケージの.zip ファイルを含むプロジェクトディレクトリから、次の Lambda CLI `create-function` コマンドを実行します。
ロールのオプションには、前のステップで作成した実行ロールの ARN を使用します。vpc-config には、デフォルト VPC のサブネットとデフォルト VPC のセキュリティグループ ID をカンマで区切ったリストを入力します。これらの値は Amazon VPC コンソール にあります。デフォルトの VPC のサブネットを検索するには、**VPCs **を選択し、AWSアカウントのデフォルト VPC を選択します。この VPC のセキュリティグループを確認するには、**[セキュリティ]** に移動して **[セキュリティグループ]** を選択します。us-east-1 リージョンが選択されていることを確認します。
```
aws lambda create-function \
--function-name AccessValkey \
--region us-east-1 \
--zip-file fileb://my_deployment_package.zip \
--role arn:aws:iam::123456789012:role/elasticache-iam-auth-app \
--handler app.lambda_handler \
--runtime python3.12 \
--timeout 30 \
--vpc-config SubnetIds=comma-separated-vpc-subnet-ids,SecurityGroupIds=default-security-group-id
```
## ステップ 3: ElastiCache で Lambda 関数をテストする
このステップでは、invoke コマンドを使用して Lambda 関数を手動で呼び出します。Lambda 関数を実行すると、UUID が生成され、Lambda コードで指定した ElastiCache キャッシュにその UUID が書き込まれます。次に、Lambda 関数はキャッシュから項目を取得します。
1. invoke コマンドを使用して Lambda 関数 (AccessValkey)AWS Lambdaを呼び出します。
```
aws lambda invoke \
--function-name AccessValkey \
--region us-east-1 \
output.txt
```
1. Lambda 関数が正常に実行されたことを、次のように確認します。
+ output.txt ファイルを確認します。
+ CloudWatch コンソールを開き、関数のロググループ (/aws/lambda/AccessValkey) を選択して、CloudWatch Logs で結果を確認します。ログストリームには、以下と同様のコマンドの出力が含まれます。
```
Success: Inserted 826e70c5f4d2478c8c18027125a3e01e. Fetched 826e70c5f4d2478c8c18027125a3e01e from Valkey.
```
+ AWS Lambdaコンソールで結果を確認します。
## ステップ 4: クリーンアップする (オプション)
クリーンアップするには、以下の手順を実行します。
### ステップ 4.1: Lambda 関数を削除する
```
aws lambda delete-function \
--function-name AccessValkey
```
### ステップ 4.2: サーバーレスキャッシュを削除する
キャッシュを削除します。
```
aws elasticache delete-serverless-cache \
--serverless-cache-name cache-01
```
ユーザーとユーザーグループを削除します。
```
aws elasticache delete-user \
--user-id default-user-disabled
aws elasticache delete-user \
--user-id iam-user-01
aws elasticache delete-user-group \
--user-group-id iam-user-group-01
```
### ステップ 4.3: IAM ロールとポリシーを削除する
```
aws iam detach-role-policy \
--role-name "elasticache-iam-auth-app" \
--policy-arn "arn:aws:iam::123456789012:policy/elasticache-allow-all"
aws iam detach-role-policy \
--role-name "elasticache-iam-auth-app" \
--policy-arn "arn:aws:iam::aws:policy/service-role/AWSLambdaVPCAccessExecutionRole"
aws iam delete-role \
--role-name "elasticache-iam-auth-app"
aws iam delete-policy \
--policy-arn "arn:aws:iam::123456789012:policy/elasticache-allow-all"
```