Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Commencer à utiliser Amazon ElastiCache
Utilisez le didacticiel pratique de cette section pour vous aider à démarrer et en savoir plus sur l'utilisation ElastiCache.
**Topics**
+ [Con ElastiCachefiguration](set-up.md)
+ [Création d'un cache sans serveur Valkey](GettingStarted.serverless-valkey.step1.md)
+ [Création d'un cache sans serveur Redis OSS](GettingStarted.serverless-redis.step1.md)
+ [Création d'un cache sans serveur Memcached](create-serverless-cache-mem.md)
+ [Tutoriels : Débuter avec Python et ElastiCache](ElastiCache-Getting-Started-Tutorials.md)
+ [Tutoriel : Configuration de Lambda pour un accès ElastiCache dans un VPC](LambdaRedis.md)
# Con ElastiCachefiguration
Pour utiliser le service ElastiCache Web, procédez comme suit.
**Topics**
+ [Inscrivez-vous pour un Compte AWS](#sign-up-for-aws)
+ [Création d’un utilisateur doté d’un accès administratif](#create-an-admin)
+ [Octroi d’un accès par programmation](#elasticache-set-up-access-key)
+ [Configuration d’autorisations](#elasticache-set-up-permissions)
+ [Configurez EC2](#elasticache-install-configure-ec2)
+ [Octroi d’un accès au réseau](#elasticache-install-grant-access-VPN)
+ [Configuration de l'accès par ligne de commande](#Download-and-install-cli)
## Inscrivez-vous pour un Compte AWS
Si vous n'en avez pas Compte AWS, procédez comme suit pour en créer un.
**Pour vous inscrire à un Compte AWS**
1. Ouvrez l'[https://portal.aws.amazon.com/billing/inscription.](https://portal.aws.amazon.com/billing/signup)
1. Suivez les instructions en ligne.
Dans le cadre de la procédure d’inscription, vous recevrez un appel téléphonique ou un SMS et vous saisirez un code de vérification en utilisant le clavier numérique du téléphone.
Lorsque vous vous inscrivez à un Compte AWS, un *Utilisateur racine d'un compte AWS*est créé. Par défaut, seul l’utilisateur racine a accès à l’ensemble des Services AWS et des ressources de ce compte. La meilleure pratique de sécurité consiste à attribuer un accès administratif à un utilisateur, et à utiliser uniquement l’utilisateur racine pour effectuer les [tâches nécessitant un accès utilisateur racine](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks).
AWS vous envoie un e-mail de confirmation une fois le processus d'inscription terminé. À tout moment, vous pouvez consulter l'activité actuelle de votre compte et gérer votre compte en accédant à [https://aws.amazon.com/](https://aws.amazon.com/)et en choisissant **Mon compte**.
## Création d’un utilisateur doté d’un accès administratif
Après vous être inscrit à un Compte AWS, sécurisez Utilisateur racine d'un compte AWSAWS IAM Identity Center, activez et créez un utilisateur administratif afin de ne pas utiliser l'utilisateur root pour les tâches quotidiennes.
**Sécurisez votre Utilisateur racine d'un compte AWS**
1. Connectez-vous en [AWS Management Console](https://console.aws.amazon.com/)tant que propriétaire du compte en choisissant **Utilisateur root** et en saisissant votre adresse Compte AWS e-mail. Sur la page suivante, saisissez votre mot de passe.
Pour obtenir de l’aide pour vous connecter en utilisant l’utilisateur racine, consultez [Connexion en tant qu’utilisateur racine](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial) dans le *Guide de l’utilisateur Connexion à AWS*.
1. Activez l’authentification multifactorielle (MFA) pour votre utilisateur racine.
Pour obtenir des instructions, voir [Activer un périphérique MFA virtuel pour votre utilisateur Compte AWS root (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html) dans le guide de l'utilisateur *IAM*.
**Création d’un utilisateur doté d’un accès administratif**
1. Activez IAM Identity Center.
Pour obtenir des instructions, consultez [Activation d’AWS IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html) dans le *Guide de l’utilisateur AWS IAM Identity Center*.
1. Dans IAM Identity Center, octroyez un accès administratif à un utilisateur.
Pour un didacticiel sur l'utilisation du Répertoire IAM Identity Center comme source d'identité, voir [Configurer l'accès utilisateur par défaut Répertoire IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html) dans le *Guide de AWS IAM Identity Center l'utilisateur*.
**Connexion en tant qu’utilisateur doté d’un accès administratif**
+ Pour vous connecter avec votre utilisateur IAM Identity Center, utilisez l’URL de connexion qui a été envoyée à votre adresse e-mail lorsque vous avez créé l’utilisateur IAM Identity Center.
Pour obtenir de l'aide pour vous connecter en utilisant un utilisateur d'IAM Identity Center, consultez la section [Connexion au portail AWS d'accès](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html) dans le *guide de l'Connexion à AWS utilisateur*.
**Attribution d’un accès à d’autres utilisateurs**
1. Dans IAM Identity Center, créez un ensemble d’autorisations qui respecte la bonne pratique consistant à appliquer les autorisations de moindre privilège.
Pour obtenir des instructions, consultez [Création d’un ensemble d’autorisations](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html) dans le *Guide de l’utilisateur AWS IAM Identity Center*.
1. Attribuez des utilisateurs à un groupe, puis attribuez un accès par authentification unique au groupe.
Pour obtenir des instructions, consultez [Ajout de groupes](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html) dans le *Guide de l’utilisateur AWS IAM Identity Center*.
## Octroi d’un accès par programmation
Les utilisateurs ont besoin d'un accès programmatique s'ils souhaitent interagir avec AWS l'extérieur du AWS Management Console. La manière d'accorder un accès programmatique dépend du type d'utilisateur qui y accède AWS.
Pour accorder aux utilisateurs un accès programmatique, choisissez l’une des options suivantes.
****
| Quel utilisateur a besoin d’un accès programmatique ? | À | Méthode |
| --- | --- | --- |
| IAM | (Recommandé) Utilisez les informations d'identification de la console comme informations d'identification temporaires pour signer les demandes programmatiques adressées au AWS CLIAWS SDKs, ou AWS APIs. | Suivez les instructions de l’interface que vous souhaitez utiliser. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/AmazonElastiCache/latest/dg/set-up.html) |
| Identité de la main-d’œuvre (Utilisateurs gérés dans IAM Identity Center) | Utilisez des informations d'identification temporaires pour signer les demandes programmatiques adressées au AWS CLIAWS SDKs, ou AWS APIs. | Suivez les instructions de l’interface que vous souhaitez utiliser. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/AmazonElastiCache/latest/dg/set-up.html) |
| IAM | Utilisez des informations d'identification temporaires pour signer les demandes programmatiques adressées au AWS CLIAWS SDKs, ou AWS APIs. | Suivez les instructions de la section [Utilisation d'informations d'identification temporaires avec AWS les ressources](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html) du Guide de l'utilisateur IAM. |
| IAM | (Non recommandé)Utilisez des informations d'identification à long terme pour signer des demandes programmatiques adressées au AWS CLIAWS SDKs, ou AWS APIs. | Suivez les instructions de l’interface que vous souhaitez utiliser. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/AmazonElastiCache/latest/dg/set-up.html) |
**Voir aussi:**
+ [Qu'est-ce qu'IAM ?](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) dans le *guide de l'utilisateur IAM*.
+ [AWS Informations d'identification de sécurité](https://docs.aws.amazon.com/general/latest/gr/aws-security-credentials.html) dans la *référence AWS générale*.
## Configurez vos autorisations (nouveaux ElastiCache utilisateurs uniquement)
Pour activer l’accès, ajoutez des autorisations à vos utilisateurs, groupes ou rôles :
+ Utilisateurs et groupes dans AWS IAM Identity Center :
Créez un jeu d’autorisations. Suivez les instructions de la rubrique [Création d’un jeu d’autorisations](https://docs.aws.amazon.com//singlesignon/latest/userguide/howtocreatepermissionset.html) du *Guide de l’utilisateur AWS IAM Identity Center*.
+ Utilisateurs gérés dans IAM par un fournisseur d’identité :
Créez un rôle pour la fédération d’identité. Suivez les instructions de la rubrique [Création d’un rôle pour un fournisseur d’identité tiers (fédération)](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-idp.html) dans le *Guide de l’utilisateur IAM*.
+ Utilisateurs IAM :
+ Créez un rôle que votre utilisateur peut assumer. Suivez les instructions de la rubrique [Création d’un rôle pour un utilisateur IAM](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-user.html) dans le *Guide de l’utilisateur IAM*.
+ (Non recommandé) Attachez une politique directement à un utilisateur ou ajoutez un utilisateur à un groupe d’utilisateurs. Suivez les instructions de la rubrique [Ajout d’autorisations à un utilisateur (console)](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_users_change-permissions.html#users_change_permissions-add-console) du *Guide de l’utilisateur IAM*.
Amazon ElastiCache crée et utilise des rôles liés à des services pour fournir des ressources et accéder à d'autres AWS ressources et services en votre nom. ElastiCache Pour créer un rôle lié à un service pour vous, utilisez la politique AWS-managed nommée. `AmazonElastiCacheFullAccess` Ce rôle est préconfiguré avec l'autorisation que le service requiert pour créer un rôle lié au service en votre nom.
Vous pouvez décider de ne pas utiliser la politique par défaut et d'utiliser une politique gérée personnalisée. Dans ce cas, assurez-vous que vous disposez des autorisations pour appeler `iam:createServiceLinkedRole` ou que vous avez créé le rôle lié à un service ElastiCache.
Pour plus d’informations, consultez les ressources suivantes :
+ [Création d'une politique](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html) (IAM)
+ [AWS politiques gérées pour Amazon ElastiCache](IAM.IdentityBasedPolicies.PredefinedPolicies.md)
+ [Utilisation de rôles liés à un service pour Amazon ElastiCache](using-service-linked-roles.md)
## Configurez EC2
Vous devrez configurer une EC2 instance à partir de laquelle vous vous connecterez à votre cache.
+ Si vous ne possédez pas encore d' EC2 instance, découvrez comment configurer une EC2 instance ici : [Amazon EC2 Getting Started Guide](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_GetStarted.html).
+ Votre EC2 instance doit se trouver dans le même VPC et avoir les mêmes paramètres de groupe de sécurité que votre cache. Par défaut, Amazon ElastiCache crée un cache dans votre VPC par défaut et utilise le groupe de sécurité par défaut. Pour suivre ce didacticiel, assurez-vous que votre EC2 instance se trouve dans le VPC par défaut et possède le groupe de sécurité par défaut.
## Octroi d’un accès au réseau à votre cache à partir d’un groupe de sécurité Amazon VPC
ElastiCache les clusters basés sur des nœuds utilisent le port 6379 pour les commandes Valkey et Redis OSS, tandis que les clusters ElastiCache sans serveur utilisent à la fois les ports 6379 et 6380. Afin de connecter et d'exécuter correctement les commandes Valkey ou Redis OSS à partir de votre EC2 instance, votre groupe de sécurité doit autoriser l'accès à ces ports selon les besoins.
ElastiCache for Memcached utilise les ports 11211 et 11212 pour accepter les commandes Memcached. Afin de connecter et d'exécuter correctement les commandes Memcached à partir de votre EC2 instance, votre groupe de sécurité doit autoriser l'accès à ces ports.
1. Connectez-vous à la [ EC2 console Amazon AWS Command Line Interface et ouvrez-la](https://console.aws.amazon.com/ec2/).
1. Dans le volet de navigation, sous **Réseau et sécurité**, choisissez **Groupes de sécurité**.
1. Dans la liste des groupes de sécurité, choisissez le groupe de sécurité de votre Amazon VPC. À moins que vous n'ayez créé un groupe de sécurité à ElastiCache utiliser, ce groupe de sécurité sera nommé *par défaut*.
1. Cliquez sur l’onglet Entrant, puis :
1. Choisissez **Edit** (Modifier).
1. Choisissez **Ajouter une règle**.
1. Dans la colonne Type, choisissez **Règle TCP personnalisée**.
1. Si vous utilisez Valkey ou Redis OSS, tapez dans la zone **Plage de ports**. `6379`
Si vous utilisez Memcached, tapez dans le champ **Plage de ports**. `11211`
1. Dans le champ **Source**, choisissez **Anywhere** dont la plage de ports est comprise (0.0.0.0/0) afin que toute EC2 instance Amazon que vous lancez au sein de votre Amazon VPC puisse se connecter à votre cache.
1. Si vous utilisez le mode ElastiCache sans serveur, ajoutez une autre règle en choisissant **Ajouter une règle**.
1. Dans la colonne **Type**, choisissez **Règle TCP personnalisée**.
1. Si vous utilisez ElastiCache Redis OSS, tapez `6380` dans la zone **Plage de ports**.
Si vous utilisez ElastiCache Memcached, tapez dans le champ **Plage de ports**. `11212`
1. Dans le champ **Source**, choisissez **Anywhere** dont la plage de ports est comprise (0.0.0.0/0) afin que toute EC2 instance Amazon que vous lancez au sein de votre Amazon VPC puisse se connecter à votre cache.
1. Choisissez **Enregistrer**.
## Téléchargez et configurez l'accès en ligne de commande
**Téléchargez et installez l'utilitaire *valkey-cli*.**
Si vous utilisez ElastiCache for Valkey, l'utilitaire valkey-cli pourrait vous être utile. Si vous utilisez ElastiCache Redis OSS avec redis-cli, pensez à passer à valkey-cli car cela fonctionne également pour Redis OSS.
1. Connectez-vous à votre EC2 instance Amazon à l'aide de l'utilitaire de connexion de votre choix. Pour savoir comment vous connecter à une EC2 instance Amazon, consultez le [guide de EC2 démarrage Amazon](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_GetStarted.html).
1. Téléchargez et installez l'utilitaire valkey-cli en exécutant la commande appropriée à votre configuration.
**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
```
**Note**
Lorsque vous installez le package redis6, l’utilitaire redis6-cli est installé avec la prise en charge du chiffrement par défaut.
Il est important de disposer d'un support de compilation pour TLS lors de l'installation de valkey-cli ou de redis-cli. ElastiCache Le mode Serverless n'est accessible que lorsque le protocole TLS est activé.
Si vous vous connectez à un cluster qui n’est pas chiffré, vous n’avez pas besoin de l’option `Build_TLS=yes`.
# Création d'un cache sans serveur Valkey
Au cours de cette étape, vous allez créer un nouveau cache sur Amazon ElastiCache.
**AWS Management Console**
Pour créer un nouveau cache à l'aide de la ElastiCache console :
1. Connectez-vous au AWS Management Console et ouvrez le [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Dans le volet de navigation sur le côté gauche de la console, choisissez **Valkey caches**.
1. Sur le côté droit de la console, choisissez **Create Valkey cache**
1. Dans **Paramètres de cache**, entrez un **Nom**. Vous pouvez éventuellement entrer une **description** pour le cache.
1. Laissez les paramètres par défaut sélectionnés.
1. Cliquez sur **Créer** pour créer le cache.
1. Une fois que le cache est à l’état « ACTIVE », vous pouvez commencer à écrire et à lire des données sur le cache.
**AWS CLI**
L' AWS CLI exemple suivant crée un nouveau cache à l'aide de 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
```
Notez que la valeur du champ Statut est définie sur `CREATING`.
Pour vérifier que la création du cache ElastiCache est terminée, utilisez la `describe-serverless-caches` commande.
**Linux**
```
aws elasticache describe-serverless-caches --serverless-cache-name CacheName
```
**Windows**
```
aws elasticache describe-serverless-caches --serverless-cache-name CacheName
```
Une fois le nouveau cache créé, passez à l’[Lire et écrire des données dans le cache](GettingStarted.serverless-valkey.step2.md).
# Lire et écrire des données dans le cache
Cette section part du principe que vous avez créé une EC2 instance Amazon et que vous pouvez vous y connecter. Pour savoir comment procéder, consultez le [guide de EC2 démarrage Amazon](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_GetStarted.html).
Cette section suppose également que vous avez configuré les paramètres d'accès au VPC et de groupe de sécurité pour l' EC2 instance à partir de laquelle vous vous connectez à votre cache, et que vous avez configuré valkey-cli sur votre instance. EC2 Pour plus d’informations sur cette étape, consultez [Con ElastiCachefiguration](set-up.md).
Outre les étapes ci-dessous, si votre application est volumineuse ou globale, vous pouvez améliorer considérablement les performances de lecture en créant et en lisant des répliques. Pour plus d'informations sur cette étape plus avancée, voir[Bonnes pratiques d'utilisation des répliques de lecture](ReadReplicas.md).
**Recherche du point de terminaison de votre cache**
**AWS Management Console**
Pour trouver le point de terminaison de votre cache à l'aide de la ElastiCache console :
1. Connectez-vous à la ElastiCache console Amazon AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Dans le volet de navigation sur le côté gauche de la console, choisissez **Valkey caches**.
1. À droite de la console, cliquez sur le nom du cache que vous venez de créer.
1. Dans **Détails du cache**, localisez et copiez le point de terminaison du cache.
**AWS CLI**
L'AWS CLI exemple suivant montre comment rechercher le point de terminaison de votre nouveau cache à l'aide de la describe-serverless-caches commande. Une fois que vous avez exécuté la commande, recherchez le champ « Endpoint ».
**Linux**
```
aws elasticache describe-serverless-caches \
--serverless-cache-name CacheName
```
**Windows**
```
aws elasticache describe-serverless-caches ^
--serverless-cache-name CacheName
```
## Connectez-vous à votre Valkey Cache (Linux)
Maintenant que vous avez le point de terminaison dont vous avez besoin, vous pouvez vous connecter à votre EC2 instance et vous connecter au cache. Dans l'exemple suivant, vous utilisez l'utilitaire *valkey-cli* pour vous connecter à un cluster. La commande suivante permet de se connecter à un cache (remarque : remplacez cache-endpoint par le point de terminaison que vous avez récupéré à l’étape précédente).
```
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"
```
## Connectez-vous à votre Valkey Cache (Windows)
Maintenant que vous avez le point de terminaison dont vous avez besoin, vous pouvez vous connecter à votre EC2 instance et vous connecter au cache. Dans l'exemple suivant, vous utilisez l'utilitaire *valkey-cli* pour vous connecter à un cluster. La commande suivante permet de se connecter à un cache. Ouvrez l'invite de commande, accédez au répertoire Valkey ou Redis OSS et exécutez la commande (remarque : remplacez Cache\$1Endpoint par le point de terminaison que vous avez récupéré à l'étape précédente).
```
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"
```
Vous pouvez maintenant passer à l’[(Facultatif) Nettoyer](GettingStarted.serverless-valkey.step3.md).
# (Facultatif) Nettoyer
Si vous n'avez plus besoin du ElastiCache cache Amazon que vous avez créé, vous pouvez le supprimer. Cette étape permet de vous assurer de ne pas être facturé pour des ressources que vous n’utilisez pas. Vous pouvez utiliser la ElastiCache console AWS CLI, l'API ou l' ElastiCache API pour supprimer votre cache.
**AWS Management Console**
Pour supprimer votre cache à l’aide de la console :
1. Connectez-vous à la ElastiCache console Amazon AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Dans le volet de navigation sur le côté gauche de la console, choisissez **Valkey Caches**.
1. Cliquez sur le bouton d’option en regard du cache que vous voulez supprimer.
1. Sélectionnez **Actions** en haut à droite, puis **Supprimer**.
1. Vous pouvez éventuellement choisir de prendre un instantané final avant de supprimer votre cache.
1. Dans l’écran de confirmation **Supprimer**, entrez à nouveau le nom du cache et choisissez **Supprimer** pour supprimer le cluster ou **Annuler** pour le conserver.
Dès que votre cache passe au statut **DELETING**, vous cessez d’être facturé pour celui-ci.
**AWS CLI**
L' AWS CLI exemple suivant supprime un cache à l'aide de la delete-serverless-cache commande.
**Linux**
```
aws elasticache delete-serverless-cache \
--serverless-cache-name CacheName
```
**Windows**
```
aws elasticache delete-serverless-cache ^
--serverless-cache-name CacheName
```
Notez que la valeur du champ **Statut** est définie sur **DELETING**.
Vous pouvez maintenant passer à l’[Étapes suivantes](GettingStarted.serverless-valkey.next-steps.md).
# Étapes suivantes
Pour plus d'informations, ElastiCache consultez les pages suivantes :
+ [Travailler avec ElastiCache](WorkingWithElastiCache.md)
+ [Dimensionnement ElastiCache](Scaling.md)
+ [Journalisation et surveillance sur Amazon ElastiCache](MonitoringECMetrics.md)
+ [ElastiCache meilleures pratiques et stratégies de mise en cache](BestPractices.md)
+ [Instantané et restauration](backups.md)
+ [Surveillance des événements par Amazon SNS ElastiCache](ECEvents.md)
# Création d'un cache sans serveur Redis OSS
Au cours de cette étape, vous allez créer un nouveau cache sur Amazon ElastiCache.
**AWS Management Console**
Pour créer un nouveau cache à l'aide de la ElastiCache console :
1. Connectez-vous à la ElastiCache console AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Dans le volet de navigation sur le côté gauche de la console, choisissez les **caches Redis OSS**.
1. Sur le côté droit de la console, choisissez **Create Redis OSS cache**
1. Dans **Paramètres de cache**, entrez un **Nom**. Vous pouvez éventuellement entrer une **description** pour le cache.
1. Laissez les paramètres par défaut sélectionnés.
1. Cliquez sur **Créer** pour créer le cache.
1. Une fois que le cache est à l’état « ACTIVE », vous pouvez commencer à écrire et à lire des données sur le cache.
**AWS CLI**
L' AWS CLI exemple suivant crée un nouveau cache à l'aide de 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
```
Notez que la valeur du champ Statut est définie sur `CREATING`.
Pour vérifier que la création du cache ElastiCache est terminée, utilisez la `describe-serverless-caches` commande.
**Linux**
```
aws elasticache describe-serverless-caches --serverless-cache-name CacheName
```
**Windows**
```
aws elasticache describe-serverless-caches --serverless-cache-name CacheName
```
Une fois le nouveau cache créé, passez à l’[Lire et écrire des données dans le cache](GettingStarted.serverless-redis.step2.md).
# Lire et écrire des données dans le cache
Cette section part du principe que vous avez créé une EC2 instance Amazon et que vous pouvez vous y connecter. Pour obtenir des instructions sur la procédure à suivre, consultez le [guide de EC2 démarrage Amazon](https://aws.amazon.com/ec2/getting-started/).
Cette section suppose également que vous avez configuré les paramètres d'accès au VPC et de groupe de sécurité pour l' EC2 instance à partir de laquelle vous vous connectez à votre cache, et que vous avez configuré valkey-cli sur votre instance. EC2 Pour plus d’informations sur cette étape, consultez [Con ElastiCachefiguration](set-up.md).
**Recherche du point de terminaison de votre cache**
**AWS Management Console**
Pour trouver le point de terminaison de votre cache à l'aide de la ElastiCache console :
1. Connectez-vous à la ElastiCache console Amazon AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Dans le volet de navigation sur le côté gauche de la console, choisissez **Valkey caches **Redis** OSS caches**.
1. À droite de la console, cliquez sur le nom du cache que vous venez de créer.
1. Dans **Détails du cache**, localisez et copiez le point de terminaison du cache.
**AWS CLI**
L'AWS CLI exemple suivant montre comment rechercher le point de terminaison de votre nouveau cache à l'aide de la describe-serverless-caches commande. Une fois que vous avez exécuté la commande, recherchez le champ « Endpoint ».
**Linux**
```
aws elasticache describe-serverless-caches \
--serverless-cache-name CacheName
```
**Windows**
```
aws elasticache describe-serverless-caches ^
--serverless-cache-name CacheName
```
## Connectez-vous à votre cache Valkey ou Redis OSS (Linux)
Maintenant que vous avez le point de terminaison dont vous avez besoin, vous pouvez vous connecter à votre EC2 instance et vous connecter au cache. Dans l'exemple suivant, vous utilisez l'utilitaire *valkey-cli* pour vous connecter à un cluster. La commande suivante permet de se connecter à un cache (remarque : remplacez cache-endpoint par le point de terminaison que vous avez récupéré à l’étape précédente).
```
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"
```
## Connectez-vous à votre cache Valkey ou Redis OSS (Windows)
Maintenant que vous avez le point de terminaison dont vous avez besoin, vous pouvez vous connecter à votre EC2 instance et vous connecter au cache. Dans l'exemple suivant, vous utilisez l'utilitaire *valkey-cli* pour vous connecter à un cluster. La commande suivante permet de se connecter à un cache. Ouvrez l'invite de commande, accédez au répertoire Valkey et exécutez la commande (remarque : remplacez Cache\$1Endpoint par le point de terminaison que vous avez récupéré à l'étape précédente).
```
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"
```
Vous pouvez maintenant passer à l’[(Facultatif) Nettoyer](GettingStarted.serverless-redis.step3.md).
# (Facultatif) Nettoyer
Si vous n'avez plus besoin du ElastiCache cache Amazon que vous avez créé, vous pouvez le supprimer. Cette étape permet de vous assurer de ne pas être facturé pour des ressources que vous n’utilisez pas. Vous pouvez utiliser la ElastiCache console AWS CLI, l'API ou l' ElastiCache API pour supprimer votre cache.
**AWS Management Console**
Pour supprimer votre cache à l’aide de la console :
1. Connectez-vous à la ElastiCache console Amazon AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Dans le volet de navigation sur le côté gauche de la console, choisissez **Valkey ou Redis OSS** Caches.
1. Cliquez sur le bouton d’option en regard du cache que vous voulez supprimer.
1. Sélectionnez **Actions** en haut à droite, puis **Supprimer**.
1. Vous pouvez éventuellement choisir de prendre un instantané final avant de supprimer votre cache.
1. Dans l’écran de confirmation **Supprimer**, entrez à nouveau le nom du cache et choisissez **Supprimer** pour supprimer le cluster ou **Annuler** pour le conserver.
Dès que votre cache passe au statut **DELETING**, vous cessez d’être facturé pour celui-ci.
**AWS CLI**
L' AWS CLI exemple suivant supprime un cache à l'aide de la delete-serverless-cache commande.
**Linux**
```
aws elasticache delete-serverless-cache \
--serverless-cache-name CacheName
```
**Windows**
```
aws elasticache delete-serverless-cache ^
--serverless-cache-name CacheName
```
Notez que la valeur du champ **Statut** est définie sur **DELETING**.
Vous pouvez maintenant passer à l’[Étapes suivantes](GettingStarted.serverless-redis.next-steps.md).
# Étapes suivantes
Pour plus d'informations, ElastiCache consultez les pages suivantes :
+ [Travailler avec ElastiCache](WorkingWithElastiCache.md)
+ [Dimensionnement ElastiCache](Scaling.md)
+ [Journalisation et surveillance sur Amazon ElastiCache](MonitoringECMetrics.md)
+ [ElastiCache meilleures pratiques et stratégies de mise en cache](BestPractices.md)
+ [Instantané et restauration](backups.md)
+ [Surveillance des événements par Amazon SNS ElastiCache](ECEvents.md)
# Création d'un cache sans serveur Memcached
**AWS Management Console**
Pour créer un nouveau cache sans serveur Memcached à l'aide de la console : ElastiCache
1. Connectez-vous à la ElastiCache console AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Dans le volet de navigation à gauche de la console, choisissez **Caches Memcached**.
1. Dans la partie droite de la console, choisissez **Créer un cache Memcached**.
1. Dans **Paramètres de cache**, entrez un **Nom**. Vous pouvez éventuellement entrer une **description** pour le cache.
1. Laissez les paramètres par défaut sélectionnés.
1. Cliquez sur **Créer** pour créer le cache.
1. Une fois que le cache est à l’état « ACTIVE », vous pouvez commencer à écrire et à lire des données sur le cache.
Pour créer un nouveau cache à l'aide du AWS CLI
L' AWS CLI exemple suivant crée un nouveau cache à l'aide de 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
```
Notez que la valeur du champ Statut est définie sur `CREATING`.
Pour vérifier que la création du cache ElastiCache est terminée, utilisez la `describe-serverless-caches` commande.
**Linux**
```
aws elasticache describe-serverless-caches --serverless-cache-name CacheName
```
**Windows**
```
aws elasticache describe-serverless-caches --serverless-cache-name CacheName
```
Une fois le nouveau cache créé, passez à l’[Lire et écrire des données dans le cache](read-write-cache-mem.md).
# Lire et écrire des données dans le cache
Cette section part du principe que vous avez créé une EC2 instance Amazon et que vous pouvez vous y connecter. Pour obtenir des instructions sur la procédure à suivre, consultez le [guide de EC2 démarrage Amazon](https://aws.amazon.com/ec2/getting-started/).
Par défaut, ElastiCache crée un cache dans votre VPC par défaut. Assurez-vous que votre EC2 instance est également créée dans le VPC par défaut, afin qu'elle puisse se connecter au cache.
**Recherche du point de terminaison de votre cache**
**AWS Management Console**
Pour trouver le point de terminaison de votre cache à l'aide de la ElastiCache console :
1. Connectez-vous à la ElastiCache console Amazon AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Dans le volet de navigation à gauche de la console, choisissez **Caches Memcached**.
1. À droite de la console, cliquez sur le nom du cache que vous venez de créer.
1. Dans **Détails du cache**, localisez et copiez le point de terminaison du cache.
**AWS CLI**
L'AWS CLI exemple suivant montre comment rechercher le point de terminaison de votre nouveau cache à l'aide de la describe-serverless-caches commande. Une fois que vous avez exécuté la commande, recherchez le champ « Endpoint ».
**Linux**
```
aws elasticache describe-serverless-caches \
--serverless-cache-name CacheName
```
**Windows**
```
aws elasticache describe-serverless-caches ^
--serverless-cache-name CacheName
```
## Connexion à l’aide d’OpenSSL
Pour en savoir plus sur la connexion à l’aide d’OpenSSL, consultez [ElastiCache chiffrement en transit (TLS)](in-transit-encryption.md).
## Connexion à l’aide du client Java Memcached
```
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");
}
}
```
## Connexion à l’aide du client PHP Memcached
```
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);
?>
```
## Connexion à l’aide du client Python Memcached (Pymemcache)
Voir [https://pymemcache.readthedocs. io/en/latest/getting](https://pymemcache.readthedocs.io/en/latest/getting_started.html)\$1started.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"
```
## Connectez-vous à l'aide du NodeJS/TS client Memcached (Memcache Electrode-IO)
[Voir [https://github.com/electrode-io/memcache et memcache-client](https://github.com/electrode-io/memcache) https://www.npmjs.com/package/](https://www.npmjs.com/package/memcache-client)
Procédez à l’installation via `npm i memcache-client`
Dans l’application, créez un client TLS Memcached comme suit :
```
var memcache = require("memcache-client");
const client = new memcache.MemcacheClient({server: "{cluster_endpoint}:11211", tls: {}});
client.set("key", "value");
```
## Connexion à l’aide du client Rust Memcached (rust-memcache)
Voir [https://crates. io/crates/memcache](https://crates.io/crates/memcache)et [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();
```
## Connexion à l’aide du client Go Memcached (Gomemcache)
Voir [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)
```
## Connexion à l’aide du client Ruby Memcached (Dalli)
Voir [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")
```
## Connect à l'aide du client .NET Memcached () EnyimMemcachedCore
Consultez [https://github.com/cnblogs/EnyimMemcachedCore](https://github.com/cnblogs/EnyimMemcachedCore)
```
"MemcachedClient": {
"Servers": [
{
"Address": "{cluster_endpoint}",
"Port": 11211
}
],
"UseSslStream": true
}
```
Vous pouvez maintenant passer à l’[(Facultatif) Nettoyer](read-write-cleanup-mem.md).
# (Facultatif) Nettoyer
**À l'aide du AWS Management Console**
La procédure suivante supprime un cache unique de votre déploiement. Pour supprimer plusieurs caches, répétez la procédure pour chaque cache à supprimer. Vous n’avez pas besoin d’attendre la fin de la suppression d’un cache avant de démarrer la procédure pour en supprimer un autre.
**Pour supprimer un cache**
1. Connectez-vous à la ElastiCache console Amazon AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Dans le tableau de bord de la ElastiCache console, choisissez le moteur qui s'exécute sur le cache que vous souhaitez supprimer. La liste de tous les caches exécutant le moteur choisi s’affiche.
1. Pour choisir le cache à supprimer, choisissez son nom dans la liste des caches.
**Important**
Vous ne pouvez supprimer qu'un seul cache à la fois depuis la ElastiCache console. Le choix de plusieurs caches désactive l’opération de suppression.
1. Pour **Actions**, choisissez **Supprimer**.
1. Dans l’écran de confirmation **Supprimer le cache**, choisissez **Supprimer** pour supprimer le cache ou **Annuler** pour le conserver.
1. Si vous avez choisi **Supprimer**, le statut du cache passe à *deleting*.
Dès que votre cache passe au statut **DELETING**, vous cessez d’être facturé pour celui-ci.
**À l'aide du AWS CLI**
Le code suivant supprime le cache my-cache.
```
aws elasticache delete-serverless-cache --serverless-cache-name my-cache
```
L'action delete-serverless-cache CLI ne supprime qu'un seul cache sans serveur. Pour supprimer plusieurs caches, appelez delete-serverless-cache chaque cache sans serveur que vous souhaitez supprimer. Vous n’avez pas besoin d’attendre que la suppression d’un cache sans serveur soit terminée avant d’en supprimer un autre.
**Pour Linux, macOS ou Unix :**
```
aws elasticache delete-serverless-cache \
--serverless-cache-name my-cache
```
**Pour Windows:**
```
aws elasticache delete-serverless-cache ^
--serverless-cache-name my-cache
```
Pour plus d'informations, consultez AWS CLI la ElastiCache rubrique dédiée delete-serverless-cache.
Vous pouvez maintenant passer à l’[Étapes suivantes](next-steps-mem.md).
# Étapes suivantes
Pour plus d'informations ElastiCache sur :
+ [Travailler avec ElastiCache](WorkingWithElastiCache.md)
+ [Dimensionnement ElastiCache](Scaling.md)
+ [Quotas pour ElastiCache](quota-limits.md)
+ [ElastiCache meilleures pratiques et stratégies de mise en cache](BestPractices.md)
+ [Affichage des ElastiCache événements](ECEvents.Viewing.md)
# Tutoriels : Débuter avec Python et ElastiCache
Cette section contient des didacticiels pratiques pour vous aider à en savoir plus sur ElastiCache Valkey et Redis OSS. Nous vous invitons à utiliser l'un de nos didacticiels spécifiques au langage.
**Note**
AWS SDKs sont disponibles dans une grande variété de langues. Pour obtenir la liste complète, consultez [Outils d'Amazon Web Services](https://aws.amazon.com/tools/).
**Topics**
+ [Python et ElastiCache](ElastiCache-Getting-Started-Tutorials-Python.md)
# Python et ElastiCache
Dans ce didacticiel, vous allez utiliser le AWS SDK pour Python (Boto3) pour écrire des programmes simples permettant d'effectuer les opérations suivantes : ElastiCache
+ Créer ElastiCache pour les clusters Redis OSS (mode cluster activé et mode cluster désactivé)
+ Vérifiez si des utilisateurs ou des groupes d'utilisateurs existent, sinon créez-les. (Cette fonctionnalité est disponible avec Valkey 7.2 et versions ultérieures, et avec Redis OSS 6.0 à 7.1.)
+ Connect à ElastiCache
+ Effectuez des opérations telles que le réglage et l'obtention de chaînes, la lecture et l'écriture sur des streams, ainsi que la publication et l'abonnement à Pub/Sub une chaîne.
Au cours de ce didacticiel, vous pouvez consulter la documentation du AWS SDK pour Python (Boto). La section suivante est spécifique à ElastiCache : client de [ElastiCache bas niveau](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/elasticache.html)
## Prérequis du didacticiel
+ Configurez une cléAWS d'accès pour utiliser le AWS SDKs. Pour de plus amples informations, veuillez consulter [Con ElastiCachefiguration](set-up.md).
+ Installer Python 3.0 ou version ultérieure. Pour plus d'informations, rendez-vous sur [https://www.python.org/downloads](https://www.python.org/downloads). Pour plus d'informations, consultez la page [Quickstart](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/quickstart.html) dans la documentation Boto 3.
**Topics**
+ [Prérequis du didacticiel](#ElastiCache-Getting-Started-Tutorials-Prerquisites)
+ [Tutoriel : Création de ElastiCache clusters et d'utilisateurs](#ElastiCache-Getting-Started-Tutorials-Create-Cluster-and-Users)
+ [Tutoriel : Connexion à ElastiCache](#ElastiCache-Getting-Started-Tutorials-Connecting)
+ [Exemples d’utilisation](#ElastiCache-Getting-Started-Tutorials-Usage)
## Tutoriel : Création de ElastiCache clusters et d'utilisateurs
Les exemples suivants utilisent le SDK boto3 ElastiCache pour les opérations de gestion Redis OSS (création de clusters ou d'utilisateurs) et redis-py-cluster redis-py/ pour le traitement des données.
**Topics**
+ [Créer un cluster en mode cluster désactivé](#ElastiCache-Getting-Started-Tutorials-Create-Cluster)
+ [Créer un cluster en mode cluster désactivé avec TLS et RBAC](#ElastiCache-Getting-Started-Tutorials-RBAC)
+ [Créer un cluster Redis en mode activé](#ElastiCache-Getting-Started-Tutorials-Cluster-Enabled)
+ [Créer un cluster en mode cluster activé avec TLS et RBAC](#ElastiCache-Getting-Started-Tutorials-Cluster-RBAC)
+ [Vérifiez s'ils users/usergroup existent, sinon créez-les](#ElastiCache-Getting-Started-Tutorials-Users)
### Créer un cluster en mode cluster désactivé
Copiez le programme suivant et collez-le dans un fichier nommé *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)
```
Pour exécuter le programme, saisissez la commande suivante.
`python CreateClusterModeDisabledCluster.py`
Pour de plus amples informations, veuillez consulter [Gestion des clusters dans ElastiCache](Clusters.md).
### Créer un cluster en mode cluster désactivé avec TLS et RBAC
Pour garantir la sécurité, vous pouvez utiliser TLS (Transport Layer Security) et RBAC (Role Based Access Control) lors de la création d'un cluster en mode cluster désactivé. Contrairement à Valkey ou Redis OSS AUTH, où tous les clients authentifiés ont un accès complet au groupe de réplication si leur jeton est authentifié, le RBAC vous permet de contrôler l'accès au cluster par le biais de groupes d'utilisateurs. Ces groupes d'utilisateurs sont conçus comme un moyen d'organiser l'accès aux groupes de réplication. Pour de plus amples informations, veuillez consulter [Contrôle d'accès basé sur les rôles (RBAC)](Clusters.RBAC.md).
Copiez le programme suivant et collez-le dans un fichier nommé *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)
```
Pour exécuter le programme, saisissez la commande suivante.
`python ClusterModeDisabledWithRBAC.py`
Pour de plus amples informations, veuillez consulter [Gestion des clusters dans ElastiCache](Clusters.md).
### Créer un cluster Redis en mode activé
Copiez le programme suivant et collez-le dans un fichier nommé *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)
```
Pour exécuter le programme, saisissez la commande suivante.
`python ClusterModeEnabled.py`
Pour de plus amples informations, veuillez consulter [Gestion des clusters dans ElastiCache](Clusters.md).
### Créer un cluster en mode cluster activé avec TLS et RBAC
Pour garantir la sécurité, vous pouvez utiliser TLS (Transport Layer Security) et RBAC (Role Based Access Control) lors de la création d'un cluster en mode cluster activé. Contrairement à Valkey ou Redis OSS AUTH, où tous les clients authentifiés ont un accès complet au groupe de réplication si leur jeton est authentifié, le RBAC vous permet de contrôler l'accès au cluster par le biais de groupes d'utilisateurs. Ces groupes d'utilisateurs sont conçus comme un moyen d'organiser l'accès aux groupes de réplication. Pour de plus amples informations, veuillez consulter [Contrôle d'accès basé sur les rôles (RBAC)](Clusters.RBAC.md).
Copiez le programme suivant et collez-le dans un fichier nommé *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)
```
Pour exécuter le programme, saisissez la commande suivante.
`python ClusterModeEnabledWithRBAC.py`
Pour de plus amples informations, veuillez consulter [Gestion des clusters dans ElastiCache](Clusters.md).
### Vérifiez s'ils users/usergroup existent, sinon créez-les
Avec RBAC, vous créez des utilisateurs et leur attribuez des autorisations spécifiques à l'aide d'une chaîne d'accès. Vous assignez les utilisateurs à des groupes d'utilisateurs correspondant à un rôle spécifique (administrateurs, ressources humaines) qui sont ensuite déployés dans un ou plusieurs groupes ElastiCache de réplication Redis OSS. Vous pouvez ainsi établir des limites de sécurité entre les clients utilisant le ou les mêmes groupes de réplication Valkey ou Redis OSS et empêcher les clients d'accéder aux données des autres. Pour de plus amples informations, veuillez consulter [Contrôle d'accès basé sur les rôles (RBAC)](Clusters.RBAC.md).
Copiez le programme suivant et collez-le dans un fichier nommé *UserAndUserGroups.py.* Mettez à jour le mécanisme de fourniture des informations d'identification. Dans cet exemple, les informations d'identification sont affichées comme remplaçables et un élément non déclaré leur est affecté. Évitez de coder en dur les informations d'identification.
Cet exemple utilise une chaîne d'accès contenant les autorisations de l'utilisateur. Pour plus d'informations sur les chaînes d'accès, voir[Définition des autorisations à l'aide d'une chaîne d'accès](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)
```
Pour exécuter le programme, saisissez la commande suivante.
`python UserAndUserGroups.py`
## Tutoriel : Connexion à ElastiCache
Les exemples suivants utilisent le client Valkey ou Redis OSS pour se connecter à. ElastiCache
**Topics**
+ [Connexion à un cluster en mode cluster désactivé](#ElastiCache-Getting-Started-Tutorials-Connecting-cluster-mode-disabled)
+ [Connexion à un cluster en mode cluster activé](#ElastiCache-Getting-Started-Tutorials-Connecting-cluster-mode-enabled)
### Connexion à un cluster en mode cluster désactivé
Copiez le programme suivant et collez-le dans un fichier nommé *ConnectClusterModeDisabled.py.* Mettez à jour le mécanisme de fourniture des informations d'identification. Dans cet exemple, les informations d'identification sont affichées comme remplaçables et un élément non déclaré leur est affecté. Évitez de coder en dur les informations d'identification.
```
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")
```
Pour exécuter le programme, saisissez la commande suivante.
`python ConnectClusterModeDisabled.py`
### Connexion à un cluster en mode cluster activé
Copiez le programme suivant et collez-le dans un fichier nommé *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")
```
Pour exécuter le programme, saisissez la commande suivante.
`python ConnectClusterModeEnabled.py`
## Exemples d’utilisation
Les exemples suivants utilisent le SDK boto3 ElastiCache pour fonctionner avec ElastiCache Redis OSS.
**Topics**
+ [Définir et obtenir des chaînes](#ElastiCache-Getting-Started-Tutorials-set-strings)
+ [Définir et obtenir un hachage avec plusieurs éléments](#ElastiCache-Getting-Started-Tutorials-set-hash)
+ [Publier (écrire) et s'abonner (lire) depuis une Pub/Sub chaîne](#ElastiCache-Getting-Started-Tutorials-pub-sub)
+ [Écrire et lire à partir d'un flux](#ElastiCache-Getting-Started-Tutorials-read-write-stream)
### Définir et obtenir des chaînes
Copiez le programme suivant et collez-le dans un fichier nommé *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))
```
Pour exécuter le programme, saisissez la commande suivante.
`python SetAndGetStrings.py`
### Définir et obtenir un hachage avec plusieurs éléments
Copiez le programme suivant et collez-le dans un fichier nommé *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))
```
Pour exécuter le programme, saisissez la commande suivante.
`python SetAndGetHash.py`
### Publier (écrire) et s'abonner (lire) depuis une Pub/Sub chaîne
Copiez le programme suivant et collez-le dans un fichier nommé *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)
```
Pour exécuter le programme, saisissez la commande suivante.
`python PubAndSub.py`
### Écrire et lire à partir d'un flux
Copiez le programme suivant et collez-le dans un fichier nommé *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)
```
Pour exécuter le programme, saisissez la commande suivante.
`python ReadWriteStream.py`
# Tutoriel : Configuration de Lambda pour un accès ElastiCache dans un VPC
Dans ce didacticiel, vous apprendrez à créer un cache ElastiCache sans serveur, à créer une fonction Lambda, puis à tester la fonction Lambda et éventuellement à la nettoyer ensuite.
**Topics**
+ [Étape 1 : Création d'un cache ElastiCache sans serveur.](#LambdaRedis.step1)
+ [Étape 2 : créer une fonction Lambda pour ElastiCache](#LambdaRedis.step2)
+ [Étape 3 : tester la fonction Lambda avec ElastiCache](#LambdaRedis.step3)
+ [Étape 4 : Nettoyage (facultatif)](#LambdaRedis.step4)
## Étape 1 : Création d'un cache ElastiCache sans serveur.
Pour créer un cache sans serveur, procédez comme suit.
### Étape 1.1 : Création d'un cache sans serveur
Au cours de cette étape, vous créez un cache sans serveur dans le VPC Amazon par défaut de la région us-east-1 de votre compte à l'aide de la (CLI).AWS Command Line Interface Pour plus d'informations sur la création d'un cache sans serveur à l'aide de la ElastiCache console ou de l'API, consultez[Création d'un cache sans serveur Redis OSS](GettingStarted.serverless-redis.step1.md).
```
aws elasticache create-serverless-cache \
--serverless-cache-name cache-01 \
--description "ElastiCache IAM auth application" \
--engine valkey
```
Notez que la valeur du champ Statut est définie sur `CREATING`. La création de votre cache peut prendre une minute. ElastiCache
### Étape 1.2 : Copier le point de terminaison du cache sans serveur
Vérifiez que ElastiCache pour Redis, OSS a terminé de créer le cache avec la `describe-serverless-caches` commande.
```
aws elasticache describe-serverless-caches \
--serverless-cache-name cache-01
```
Copiez l’adresse du point de terminaison affichée dans la sortie. Vous aurez besoin de cette adresse lorsque vous allez créer le package de déploiement de votre fonction Lambda.
### Étape 1.3 : Création d'un rôle IAM
1. Créez un document de stratégie d'approbation IAM, comme indiqué ci-dessous, pour votre rôle afin d'autoriser votre compte à assumer le nouveau rôle. Enregistrez la politique dans un fichier nommé *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. Créez un document de politique IAM, comme indiqué ci-dessous. Enregistrez la politique dans un fichier nommé *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. Créez un rôle IAM.
```
aws iam create-role \
--role-name "elasticache-iam-auth-app" \
--assume-role-policy-document file://trust-policy.json
```
1. Créez la politique IAM.
```
aws iam create-policy \
--policy-name "elasticache-allow-all" \
--policy-document file://policy.json
```
1. Attachez la politique gérée IAM au rôle.
```
aws iam attach-role-policy \
--role-name "elasticache-iam-auth-app" \
--policy-arn "arn:aws:iam::123456789012:policy/elasticache-allow-all"
```
### Étape 1.4 : Création d'un utilisateur par défaut
1. Créez un nouvel utilisateur par défaut.
```
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. Créez un compte utilisateur prenant en charge 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. Créez un groupe d'utilisateurs et attachez l'utilisateur.
```
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
```
## Étape 2 : créer une fonction Lambda pour ElastiCache
Pour créer une fonction Lambda permettant d'accéder au ElastiCache cache, procédez comme suit.
### Étape 2.1 : Création d'une fonction Lambda
Dans ce didacticiel, nous fournissons un exemple de code en Python pour votre fonction Lambda.
**Python**
L'exemple de code Python suivant lit et écrit un élément dans votre ElastiCache cache. Copiez le code et enregistrez-le dans un fichier nommé `app.py`. Assurez-vous de remplacer la `elasticache_endpoint` valeur du code par l'adresse du point de terminaison que vous avez copiée à l'étape précédente.
```
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"
```
Ce code utilise la bibliothèque Python redis-py pour mettre des éléments dans votre cache et les récupérer. Ce code utilise des outils de cache pour mettre en cache les jetons d'authentification IAM générés pendant 15 minutes. Pour créer un package de déploiement contenant redis-py et cachetools, effectuez les étapes suivantes.
Dans le répertoire de votre projet contenant le fichier de code source app.py, créez un package de dossiers dans lequel installer les bibliothèques redis-py et cachetools.
```
mkdir package
```
Installez redis-py, cachetools en utilisant pip.
```
pip install --target ./package redis
pip install --target ./package cachetools
```
Créez un fichier .zip contenant les bibliothèques redis-py et cachetools. Sous Linux et macOS, exécutez la commande suivante. Sous Windows, utilisez l'utilitaire zip de votre choix pour créer un fichier .zip avec les bibliothèques redis-py et cachetools à la racine.
```
cd package
zip -r ../my_deployment_package.zip .
```
Ajoutez votre code de fonction dans le fichier .zip. Sous Linux et macOS, exécutez la commande suivante. Sous Windows, utilisez l'utilitaire zip de votre choix pour ajouter app.py à la racine de votre fichier .zip.
```
cd ..
zip my_deployment_package.zip app.py
```
### Étape 2.2 : Créer un rôle IAM (rôle d'exécution)
Attachez la politique AWS gérée nommée `AWSLambdaVPCAccessExecutionRole` au rôle.
```
aws iam attach-role-policy \
--role-name "elasticache-iam-auth-app" \
--policy-arn "arn:aws:iam::aws:policy/service-role/AWSLambdaVPCAccessExecutionRole"
```
### Étape 2.3 : Charger le package de déploiement (créer la fonction Lambda)
Dans cette étape, vous créez la fonction Lambda (AccessValkey) à l'aide de la commande AWS CLI create-function.
Dans le répertoire du projet qui contient le fichier .zip de votre package de déploiement, exécutez la commande Lambda `create-function` CLI suivante.
Pour l'option de rôle, utilisez l'ARN du rôle d'exécution que vous avez créé à l'étape précédente. Pour le vpc-config, entrez des listes séparées par des virgules des sous-réseaux de votre VPC par défaut et de l'ID du groupe de sécurité de votre VPC par défaut. Vous trouverez ces valeurs dans la console Amazon VPC. Pour trouver les sous-réseaux de votre VPC par défaut, choisissez **Votre VPCs**, puis choisissez le VPC par défaut de votre AWS compte. Pour trouver le groupe de sécurité pour ce VPC, accédez à **Sécurité** et choisissez Groupes de **sécurité**. Assurez-vous que la région us-east-1 est sélectionnée.
```
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
```
## Étape 3 : tester la fonction Lambda avec ElastiCache
Au cours de cette étape, vous invoquez la fonction Lambda manuellement à l'aide de la commande invoke. Lorsque la fonction Lambda s'exécute, elle génère un UUID et l'écrit dans le ElastiCache cache que vous avez spécifié dans votre code Lambda. La fonction Lambda récupère ensuite l'élément à partir du cache.
1. Appelez la fonction Lambda (AccessValkey) à l'aide de la commande AWS Lambda invoke.
```
aws lambda invoke \
--function-name AccessValkey \
--region us-east-1 \
output.txt
```
1. Vérifiez que l'exécution de la fonction Lambda a réussi comme suit :
+ Passez en revue le fichier output.txt.
+ Vérifiez les résultats dans CloudWatch Logs en ouvrant la CloudWatch console et en choisissant le groupe de journaux pour votre fonction (/aws/lambda/AccessValkey). Le flux de journaux doit contenir un résultat similaire à ce qui suit :
```
Success: Inserted 826e70c5f4d2478c8c18027125a3e01e. Fetched 826e70c5f4d2478c8c18027125a3e01e from Valkey.
```
+ Passez en revue les résultats dans la AWS Lambda console.
## Étape 4 : Nettoyage (facultatif)
Pour nettoyer, procédez comme suit.
### Étape 4.1 : Supprimer la fonction Lambda
```
aws lambda delete-function \
--function-name AccessValkey
```
### Étape 4.2 : Supprimer le cache sans serveur
Supprimez le cache.
```
aws elasticache delete-serverless-cache \
--serverless-cache-name cache-01
```
Supprimez des utilisateurs et des groupes d'utilisateurs.
```
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
```
### Étape 4.3 : Supprimer le rôle et les politiques 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"
```